CYCLUS
Loading...
Searching...
No Matches
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
9namespace cyclus {
10
11Hdf5Back::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
41void Hdf5Back::Close() {
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
72Hdf5Back::~Hdf5Back() {
73 if (!closed_)
74 Close();
75}
76
77void Hdf5Back::Notify(DatumList data) {
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
99template <>
100std::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.data(), rawkey, CYCLUS_SHA1_SIZE);
105 const std::vector<hsize_t> idx(key.begin(), key.end());
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
133template <>
134Blob Hdf5Back::VLRead<Blob, BLOB>(const char* rawkey) {
135 // key is used as offset
136 Digest key;
137 memcpy(key.data(), rawkey, CYCLUS_SHA1_SIZE);
138 const std::vector<hsize_t> idx(key.begin(), key.end());
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
163QueryResult 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 }
2763 case VL_MAP_VL_STRING_VL_STRING: {
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 }
2861 case MAP_PAIR_INT_STRING_DOUBLE: {
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 }
2908 case VL_MAP_PAIR_INT_STRING_DOUBLE: {
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 }
2920 case MAP_PAIR_INT_VL_STRING_DOUBLE: {
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 }
2961 case VL_MAP_PAIR_INT_VL_STRING_DOUBLE: {
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 }
3016 case MAP_STRING_VL_VECTOR_DOUBLE: {
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 }
3051 case VL_MAP_STRING_VECTOR_DOUBLE: {
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 }
3063 case MAP_VL_STRING_VECTOR_DOUBLE: {
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 }
3100 case MAP_VL_STRING_VL_VECTOR_DOUBLE: {
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 }
3129 case VL_MAP_STRING_VL_VECTOR_DOUBLE: {
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 }
3141 case VL_MAP_VL_STRING_VECTOR_DOUBLE: {
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 }
3153 case VL_MAP_VL_STRING_VL_VECTOR_DOUBLE: {
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 }
3165 case MAP_STRING_MAP_INT_DOUBLE: {
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 }
3219 case MAP_STRING_VL_MAP_INT_DOUBLE: {
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 }
3254 case VL_MAP_STRING_MAP_INT_DOUBLE: {
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 }
3266 case MAP_VL_STRING_MAP_INT_DOUBLE: {
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 }
3314 case MAP_VL_STRING_VL_MAP_INT_DOUBLE: {
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 }
3343 case VL_MAP_STRING_VL_MAP_INT_DOUBLE: {
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 }
3355 case VL_MAP_VL_STRING_MAP_INT_DOUBLE: {
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 }
3367 case VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE: {
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 }
3379 case MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
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 }
3443 case VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
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 }
3455 case MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
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 }
3513 case MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
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 }
3558 case VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
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 }
3570 case VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
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 }
3582 case MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
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 }
3621 case VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
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 }
3633 case MAP_INT_MAP_STRING_DOUBLE: {
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 }
3687 case MAP_INT_MAP_VL_STRING_DOUBLE: {
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 }
3735 case VL_MAP_INT_MAP_STRING_DOUBLE: {
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 }
3747 case VL_MAP_INT_MAP_VL_STRING_DOUBLE: {
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 }
3759 case MAP_INT_VL_MAP_STRING_DOUBLE: {
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 }
3788 case MAP_INT_VL_MAP_VL_STRING_DOUBLE: {
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 }
3817 case VL_MAP_INT_VL_MAP_STRING_DOUBLE: {
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 }
3829 case VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE: {
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 }
3841 case MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
3921 case MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
3995 case MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4069 case MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4137 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
4172 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
4207 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4242 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4277 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
4351 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
4419 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4487 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4549 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
4578 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
4607 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4636 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4665 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
4677 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
4689 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4701 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4713 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
4725 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
4737 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4749 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4761 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
4773 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
4785 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4797 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4809 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
4821 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
4833 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
4845 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
4903 case MAP_STRING_PAIR_STRING_VECTOR_DOUBLE: {
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 }
4962 case MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
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 }
5013 case MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
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 }
5066 case MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
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 }
5111 case MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE: {
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 }
5164 case MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
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 }
5211 case MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
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 }
5256 case MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
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 }
5295 case VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE: {
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 }
5307 case VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE: {
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 }
5319 case VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
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 }
5331 case VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
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 }
5343 case VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
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 }
5355 case VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
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 }
5367 case VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
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 }
5379 case VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
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 }
5391 case MAP_STRING_MAP_STRING_INT: {
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 }
5451 case MAP_STRING_MAP_VL_STRING_INT: {
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 }
5505 case MAP_STRING_VL_MAP_STRING_INT: {
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 }
5540 case MAP_STRING_VL_MAP_VL_STRING_INT: {
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 }
5575 case MAP_VL_STRING_MAP_STRING_INT: {
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 }
5629 case MAP_VL_STRING_VL_MAP_STRING_INT: {
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 }
5658 case MAP_VL_STRING_MAP_VL_STRING_INT: {
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 }
5706 case MAP_VL_STRING_VL_MAP_VL_STRING_INT: {
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 }
5735 case VL_MAP_STRING_MAP_STRING_INT: {
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 }
5747 case VL_MAP_VL_STRING_MAP_STRING_INT: {
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 }
5759 case VL_MAP_STRING_VL_MAP_STRING_INT: {
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 }
5771 case VL_MAP_STRING_MAP_VL_STRING_INT: {
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 }
5783 case VL_MAP_STRING_VL_MAP_VL_STRING_INT: {
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 }
5795 case VL_MAP_VL_STRING_MAP_VL_STRING_INT: {
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 }
5807 case VL_MAP_VL_STRING_VL_MAP_STRING_INT: {
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 }
5819 case VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT: {
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 }
5831 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE: {
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 }
5899 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE: {
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 }
5961 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE: {
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 }
6004 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE: {
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 }
6047 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE: {
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 }
6059 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE: {
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 }
6071 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE: {
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 }
6083 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE: {
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 }
6095 case PAIR_INT_PAIR_STRING_STRING: {
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 }
6141 case PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
6181 case PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
6221 case PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
6279 case PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE: {
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 }
6336 case PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE: {
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 }
6387 case PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE: {
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 }
6419 case PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE: {
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 }
6451 case PAIR_DOUBLE_MAP_INT_DOUBLE: {
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 }
6492 case PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
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 }
6514 case VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
6571 case VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
6622 case VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
6673 case VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
6718 case VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
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 }
6730 case VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
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 }
6742 case VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
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 }
6754 case VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
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 }
6766 case PAIR_STRING_VECTOR_DOUBLE: {
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 }
6802 case PAIR_VL_STRING_VECTOR_DOUBLE: {
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 }
6832 case PAIR_STRING_VL_VECTOR_DOUBLE: {
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 }
6860 case PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
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 }
6882 case MAP_PAIR_STRING_STRING_INT: {
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 }
6935 case MAP_PAIR_STRING_VL_STRING_INT: {
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 }
6982 case MAP_PAIR_VL_STRING_STRING_INT: {
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 }
7029 case MAP_PAIR_VL_STRING_VL_STRING_INT: {
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 }
7070 case VL_MAP_PAIR_STRING_STRING_INT: {
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 }
7082 case VL_MAP_PAIR_STRING_VL_STRING_INT: {
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 }
7094 case VL_MAP_PAIR_VL_STRING_STRING_INT: {
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 }
7106 case VL_MAP_PAIR_VL_STRING_VL_STRING_INT: {
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 }
7118 case MAP_STRING_MAP_STRING_DOUBLE: {
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 }
7178 case MAP_STRING_MAP_VL_STRING_DOUBLE: {
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 }
7232 case MAP_STRING_VL_MAP_STRING_DOUBLE: {
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 }
7267 case MAP_STRING_VL_MAP_VL_STRING_DOUBLE: {
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 }
7302 case MAP_VL_STRING_MAP_STRING_DOUBLE: {
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 }
7356 case MAP_VL_STRING_VL_MAP_STRING_DOUBLE: {
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 }
7385 case MAP_VL_STRING_MAP_VL_STRING_DOUBLE: {
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 }
7433 case MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE: {
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 }
7462 case VL_MAP_STRING_MAP_STRING_DOUBLE: {
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 }
7474 case VL_MAP_VL_STRING_MAP_STRING_DOUBLE: {
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 }
7486 case VL_MAP_STRING_VL_MAP_STRING_DOUBLE: {
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 }
7498 case VL_MAP_STRING_MAP_VL_STRING_DOUBLE: {
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 }
7510 case VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE: {
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 }
7522 case VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE: {
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 }
7534 case VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE: {
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 }
7546 case VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE: {
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
7586QueryResult 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
7606void 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
7619void 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
7654hid_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
7662std::string Hdf5Back::Name() {
7663 return path_;
7664}
7665
7666void 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::map;
7673 Datum::Vals vals = d->vals();
7674 hsize_t nvals = vals.size();
7675 Datum::Shape shape;
7676 Datum::Shapes shapes = d->shapes();
7677
7678 herr_t status;
7679 size_t dst_size = 0;
7680 size_t* dst_offset = new size_t[nvals];
7681 size_t* dst_sizes = new size_t[nvals];
7682 hid_t field_types[nvals];
7683 DbTypes* dbtypes = new DbTypes[nvals];
7684 const char* field_names[nvals];
7685 for (int i = 0; i < nvals; ++i) {
7686 dst_offset[i] = dst_size;
7687 field_names[i] = vals[i].first;
7688 const std::type_info& valtype = vals[i].second.type();
7689 if(valtype==typeid(std::map<std::string, std::map<std::string, double>>)){
7690 shape=shapes[i];
7691 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
7692 dbtypes[i]=VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE;
7693 hid_t item_type0;
7694 hid_t item_type1key;
7695 item_type1key=sha1_type_;
7696 hid_t item_type1val;
7697 hid_t item_type2key;
7698 item_type2key=sha1_type_;
7699 hid_t item_type2val;
7700 item_type2val=H5T_NATIVE_DOUBLE;
7701 hid_t item_type2valcompound;
7702 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7703 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7704 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7705 item_type1val=sha1_type_;
7706 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7707 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7708 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7709
7710 }
7711 hid_t item_type1compound;
7712 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7713 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7714 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7715 item_type0=sha1_type_;
7716 if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE)==0){
7717 vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
7718 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE]);
7719
7720 }
7721 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
7722 field_types[i]=sha1_type_;
7723
7724 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
7725 dbtypes[i]=MAP_STRING_MAP_VL_STRING_DOUBLE;
7726 hid_t item_type0;
7727 hsize_t shape01=shape[0];
7728 hid_t item_type1key;
7729 item_type1key=CreateFLStrType(shape[1]);
7730 hid_t item_type1val;
7731 hsize_t shape02=shape[2];
7732 hid_t item_type2key;
7733 item_type2key=sha1_type_;
7734 hid_t item_type2val;
7735 item_type2val=H5T_NATIVE_DOUBLE;
7736 hid_t item_type2valcompound;
7737 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7738 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7739 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7740 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
7741 hid_t item_type1compound;
7742 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]));
7743 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7744 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
7745 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7746 dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
7747 field_types[i]=item_type0;
7748 opened_types_.insert(item_type2valcompound);
7749 opened_types_.insert(item_type1val);
7750 opened_types_.insert(item_type1compound);
7751 opened_types_.insert(field_types[i]);
7752
7753 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
7754 dbtypes[i]=MAP_STRING_VL_MAP_STRING_DOUBLE;
7755 hid_t item_type0;
7756 hsize_t shape01=shape[0];
7757 hid_t item_type1key;
7758 item_type1key=CreateFLStrType(shape[1]);
7759 hid_t item_type1val;
7760 hid_t item_type2key;
7761 item_type2key=sha1_type_;
7762 hid_t item_type2val;
7763 item_type2val=H5T_NATIVE_DOUBLE;
7764 hid_t item_type2valcompound;
7765 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7766 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7767 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7768 item_type1val=sha1_type_;
7769 if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
7770 vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7771 opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
7772
7773 }
7774 hid_t item_type1compound;
7775 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
7776 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7777 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
7778 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7779 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
7780 field_types[i]=item_type0;
7781 opened_types_.insert(item_type2valcompound);
7782 opened_types_.insert(item_type1val);
7783 opened_types_.insert(item_type1compound);
7784 opened_types_.insert(field_types[i]);
7785
7786 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
7787 dbtypes[i]=MAP_STRING_VL_MAP_VL_STRING_DOUBLE;
7788 hid_t item_type0;
7789 hsize_t shape01=shape[0];
7790 hid_t item_type1key;
7791 item_type1key=CreateFLStrType(shape[1]);
7792 hid_t item_type1val;
7793 hid_t item_type2key;
7794 item_type2key=sha1_type_;
7795 hid_t item_type2val;
7796 item_type2val=H5T_NATIVE_DOUBLE;
7797 hid_t item_type2valcompound;
7798 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7799 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7800 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7801 item_type1val=sha1_type_;
7802 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7803 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7804 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7805
7806 }
7807 hid_t item_type1compound;
7808 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
7809 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7810 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
7811 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7812 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
7813 field_types[i]=item_type0;
7814 opened_types_.insert(item_type2valcompound);
7815 opened_types_.insert(item_type1val);
7816 opened_types_.insert(item_type1compound);
7817 opened_types_.insert(field_types[i]);
7818
7819 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
7820 dbtypes[i]=MAP_VL_STRING_MAP_STRING_DOUBLE;
7821 hid_t item_type0;
7822 hsize_t shape01=shape[0];
7823 hid_t item_type1key;
7824 item_type1key=sha1_type_;
7825 hid_t item_type1val;
7826 hsize_t shape02=shape[2];
7827 hid_t item_type2key;
7828 item_type2key=CreateFLStrType(shape[3]);
7829 hid_t item_type2val;
7830 item_type2val=H5T_NATIVE_DOUBLE;
7831 hid_t item_type2valcompound;
7832 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(double));
7833 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7834 H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
7835 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
7836 hid_t item_type1compound;
7837 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+sizeof(double))*shape[2]));
7838 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7839 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7840 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7841 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
7842 field_types[i]=item_type0;
7843 opened_types_.insert(item_type2valcompound);
7844 opened_types_.insert(item_type1val);
7845 opened_types_.insert(item_type1compound);
7846 opened_types_.insert(field_types[i]);
7847
7848 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
7849 dbtypes[i]=MAP_VL_STRING_VL_MAP_STRING_DOUBLE;
7850 hid_t item_type0;
7851 hsize_t shape01=shape[0];
7852 hid_t item_type1key;
7853 item_type1key=sha1_type_;
7854 hid_t item_type1val;
7855 hid_t item_type2key;
7856 item_type2key=sha1_type_;
7857 hid_t item_type2val;
7858 item_type2val=H5T_NATIVE_DOUBLE;
7859 hid_t item_type2valcompound;
7860 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7861 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7862 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7863 item_type1val=sha1_type_;
7864 if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
7865 vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7866 opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
7867
7868 }
7869 hid_t item_type1compound;
7870 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7871 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7872 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7873 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7874 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
7875 field_types[i]=item_type0;
7876 opened_types_.insert(item_type2valcompound);
7877 opened_types_.insert(item_type1val);
7878 opened_types_.insert(item_type1compound);
7879 opened_types_.insert(field_types[i]);
7880
7881 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
7882 dbtypes[i]=MAP_VL_STRING_MAP_VL_STRING_DOUBLE;
7883 hid_t item_type0;
7884 hsize_t shape01=shape[0];
7885 hid_t item_type1key;
7886 item_type1key=sha1_type_;
7887 hid_t item_type1val;
7888 hsize_t shape02=shape[2];
7889 hid_t item_type2key;
7890 item_type2key=sha1_type_;
7891 hid_t item_type2val;
7892 item_type2val=H5T_NATIVE_DOUBLE;
7893 hid_t item_type2valcompound;
7894 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7895 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7896 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7897 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
7898 hid_t item_type1compound;
7899 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]));
7900 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7901 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7902 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7903 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
7904 field_types[i]=item_type0;
7905 opened_types_.insert(item_type2valcompound);
7906 opened_types_.insert(item_type1val);
7907 opened_types_.insert(item_type1compound);
7908 opened_types_.insert(field_types[i]);
7909
7910 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
7911 dbtypes[i]=MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE;
7912 hid_t item_type0;
7913 hsize_t shape01=shape[0];
7914 hid_t item_type1key;
7915 item_type1key=sha1_type_;
7916 hid_t item_type1val;
7917 hid_t item_type2key;
7918 item_type2key=sha1_type_;
7919 hid_t item_type2val;
7920 item_type2val=H5T_NATIVE_DOUBLE;
7921 hid_t item_type2valcompound;
7922 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7923 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7924 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7925 item_type1val=sha1_type_;
7926 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7927 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7928 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7929
7930 }
7931 hid_t item_type1compound;
7932 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7933 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7934 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7935 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7936 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
7937 field_types[i]=item_type0;
7938 opened_types_.insert(item_type2valcompound);
7939 opened_types_.insert(item_type1val);
7940 opened_types_.insert(item_type1compound);
7941 opened_types_.insert(field_types[i]);
7942
7943 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]>=1){
7944 dbtypes[i]=VL_MAP_STRING_MAP_STRING_DOUBLE;
7945 hid_t item_type0;
7946 hid_t item_type1key;
7947 item_type1key=sha1_type_;
7948 hid_t item_type1val;
7949 hsize_t shape02=shape[2];
7950 hid_t item_type2key;
7951 item_type2key=sha1_type_;
7952 hid_t item_type2val;
7953 item_type2val=H5T_NATIVE_DOUBLE;
7954 hid_t item_type2valcompound;
7955 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7956 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7957 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7958 item_type1val=sha1_type_;
7959 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7960 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7961 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7962
7963 }
7964 hid_t item_type1compound;
7965 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7966 H5Tinsert(item_type1compound, "key", 0, item_type1key);
7967 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7968 item_type0=sha1_type_;
7969 if(vldts_.count(VL_MAP_STRING_MAP_STRING_DOUBLE)==0){
7970 vldts_[VL_MAP_STRING_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
7971 opened_types_.insert(vldts_[VL_MAP_STRING_MAP_STRING_DOUBLE]);
7972
7973 }
7974 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
7975 field_types[i]=sha1_type_;
7976
7977 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
7978 dbtypes[i]=VL_MAP_VL_STRING_MAP_STRING_DOUBLE;
7979 hid_t item_type0;
7980 hid_t item_type1key;
7981 item_type1key=sha1_type_;
7982 hid_t item_type1val;
7983 hsize_t shape02=shape[2];
7984 hid_t item_type2key;
7985 item_type2key=sha1_type_;
7986 hid_t item_type2val;
7987 item_type2val=H5T_NATIVE_DOUBLE;
7988 hid_t item_type2valcompound;
7989 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7990 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7991 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7992 item_type1val=sha1_type_;
7993 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7994 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7995 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7996
7997 }
7998 hid_t item_type1compound;
7999 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8000 H5Tinsert(item_type1compound, "key", 0, item_type1key);
8001 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8002 item_type0=sha1_type_;
8003 if(vldts_.count(VL_MAP_VL_STRING_MAP_STRING_DOUBLE)==0){
8004 vldts_[VL_MAP_VL_STRING_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8005 opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_STRING_DOUBLE]);
8006
8007 }
8008 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8009 field_types[i]=sha1_type_;
8010
8011 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
8012 dbtypes[i]=VL_MAP_STRING_VL_MAP_STRING_DOUBLE;
8013 hid_t item_type0;
8014 hid_t item_type1key;
8015 item_type1key=sha1_type_;
8016 hid_t item_type1val;
8017 hid_t item_type2key;
8018 item_type2key=sha1_type_;
8019 hid_t item_type2val;
8020 item_type2val=H5T_NATIVE_DOUBLE;
8021 hid_t item_type2valcompound;
8022 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8023 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8024 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8025 item_type1val=sha1_type_;
8026 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8027 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8028 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8029
8030 }
8031 hid_t item_type1compound;
8032 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8033 H5Tinsert(item_type1compound, "key", 0, item_type1key);
8034 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8035 item_type0=sha1_type_;
8036 if(vldts_.count(VL_MAP_STRING_VL_MAP_STRING_DOUBLE)==0){
8037 vldts_[VL_MAP_STRING_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8038 opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_STRING_DOUBLE]);
8039
8040 }
8041 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8042 field_types[i]=sha1_type_;
8043
8044 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
8045 dbtypes[i]=VL_MAP_STRING_MAP_VL_STRING_DOUBLE;
8046 hid_t item_type0;
8047 hid_t item_type1key;
8048 item_type1key=sha1_type_;
8049 hid_t item_type1val;
8050 hsize_t shape02=shape[2];
8051 hid_t item_type2key;
8052 item_type2key=sha1_type_;
8053 hid_t item_type2val;
8054 item_type2val=H5T_NATIVE_DOUBLE;
8055 hid_t item_type2valcompound;
8056 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8057 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8058 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8059 item_type1val=sha1_type_;
8060 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8061 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8062 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8063
8064 }
8065 hid_t item_type1compound;
8066 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8067 H5Tinsert(item_type1compound, "key", 0, item_type1key);
8068 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8069 item_type0=sha1_type_;
8070 if(vldts_.count(VL_MAP_STRING_MAP_VL_STRING_DOUBLE)==0){
8071 vldts_[VL_MAP_STRING_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8072 opened_types_.insert(vldts_[VL_MAP_STRING_MAP_VL_STRING_DOUBLE]);
8073
8074 }
8075 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8076 field_types[i]=sha1_type_;
8077
8078 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
8079 dbtypes[i]=VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE;
8080 hid_t item_type0;
8081 hid_t item_type1key;
8082 item_type1key=sha1_type_;
8083 hid_t item_type1val;
8084 hid_t item_type2key;
8085 item_type2key=sha1_type_;
8086 hid_t item_type2val;
8087 item_type2val=H5T_NATIVE_DOUBLE;
8088 hid_t item_type2valcompound;
8089 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8090 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8091 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8092 item_type1val=sha1_type_;
8093 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8094 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8095 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8096
8097 }
8098 hid_t item_type1compound;
8099 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8100 H5Tinsert(item_type1compound, "key", 0, item_type1key);
8101 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8102 item_type0=sha1_type_;
8103 if(vldts_.count(VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE)==0){
8104 vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8105 opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE]);
8106
8107 }
8108 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8109 field_types[i]=sha1_type_;
8110
8111 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
8112 dbtypes[i]=VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE;
8113 hid_t item_type0;
8114 hid_t item_type1key;
8115 item_type1key=sha1_type_;
8116 hid_t item_type1val;
8117 hsize_t shape02=shape[2];
8118 hid_t item_type2key;
8119 item_type2key=sha1_type_;
8120 hid_t item_type2val;
8121 item_type2val=H5T_NATIVE_DOUBLE;
8122 hid_t item_type2valcompound;
8123 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8124 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8125 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8126 item_type1val=sha1_type_;
8127 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8128 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8129 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8130
8131 }
8132 hid_t item_type1compound;
8133 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8134 H5Tinsert(item_type1compound, "key", 0, item_type1key);
8135 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8136 item_type0=sha1_type_;
8137 if(vldts_.count(VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE)==0){
8138 vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8139 opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE]);
8140
8141 }
8142 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8143 field_types[i]=sha1_type_;
8144
8145 }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
8146 dbtypes[i]=VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE;
8147 hid_t item_type0;
8148 hid_t item_type1key;
8149 item_type1key=sha1_type_;
8150 hid_t item_type1val;
8151 hid_t item_type2key;
8152 item_type2key=sha1_type_;
8153 hid_t item_type2val;
8154 item_type2val=H5T_NATIVE_DOUBLE;
8155 hid_t item_type2valcompound;
8156 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8157 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8158 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8159 item_type1val=sha1_type_;
8160 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8161 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8162 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8163
8164 }
8165 hid_t item_type1compound;
8166 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8167 H5Tinsert(item_type1compound, "key", 0, item_type1key);
8168 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8169 item_type0=sha1_type_;
8170 if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE)==0){
8171 vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8172 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE]);
8173
8174 }
8175 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8176 field_types[i]=sha1_type_;
8177
8178 }else{
8179 dbtypes[i]=MAP_STRING_MAP_STRING_DOUBLE;
8180 hid_t item_type0;
8181 hsize_t shape01=shape[0];
8182 hid_t item_type1key;
8183 item_type1key=CreateFLStrType(shape[1]);
8184 hid_t item_type1val;
8185 hsize_t shape02=shape[2];
8186 hid_t item_type2key;
8187 item_type2key=CreateFLStrType(shape[3]);
8188 hid_t item_type2val;
8189 item_type2val=H5T_NATIVE_DOUBLE;
8190 hid_t item_type2valcompound;
8191 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(double));
8192 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8193 H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
8194 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
8195 hid_t item_type1compound;
8196 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+sizeof(double))*shape[2]));
8197 H5Tinsert(item_type1compound, "key", 0, item_type1key);
8198 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
8199 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
8200 dst_sizes[i]=((shape[1]+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
8201 field_types[i]=item_type0;
8202 opened_types_.insert(item_type2valcompound);
8203 opened_types_.insert(item_type1val);
8204 opened_types_.insert(item_type1compound);
8205 opened_types_.insert(field_types[i]);
8206
8207 }
8208
8209 }else if(valtype==typeid(bool)){
8210 shape=shapes[i];
8211 dbtypes[i]=BOOL;
8212 hid_t item_type0;
8213 item_type0=H5T_NATIVE_CHAR;
8214 dst_sizes[i]=sizeof(char);
8215 field_types[i]=item_type0;
8216
8217 }else if(valtype==typeid(int)){
8218 shape=shapes[i];
8219 dbtypes[i]=INT;
8220 hid_t item_type0;
8221 item_type0=H5T_NATIVE_INT;
8222 dst_sizes[i]=sizeof(int);
8223 field_types[i]=item_type0;
8224
8225 }else if(valtype==typeid(float)){
8226 shape=shapes[i];
8227 dbtypes[i]=FLOAT;
8228 hid_t item_type0;
8229 item_type0=H5T_NATIVE_FLOAT;
8230 dst_sizes[i]=sizeof(float);
8231 field_types[i]=item_type0;
8232
8233 }else if(valtype==typeid(double)){
8234 shape=shapes[i];
8235 dbtypes[i]=DOUBLE;
8236 hid_t item_type0;
8237 item_type0=H5T_NATIVE_DOUBLE;
8238 dst_sizes[i]=sizeof(double);
8239 field_types[i]=item_type0;
8240
8241 }else if(valtype==typeid(std::string)){
8242 shape=shapes[i];
8243 if(shape.empty()||shape[0]<1){
8244 dbtypes[i]=VL_STRING;
8245 hid_t item_type0;
8246 item_type0=sha1_type_;
8247 dst_sizes[i]=CYCLUS_SHA1_SIZE;
8248 field_types[i]=sha1_type_;
8249
8250 }else{
8251 dbtypes[i]=STRING;
8252 field_types[i]=H5Tcopy(H5T_C_S1);
8253 H5Tset_size(field_types[i], shape[0]);
8254 H5Tset_strpad(field_types[i], H5T_STR_NULLPAD);
8255 opened_types_.insert(field_types[i]);
8256 dst_sizes[i]=sizeof(char)*shape[0];
8257
8258 }
8259
8260 }else if(valtype==typeid(cyclus::Blob)){
8261 shape=shapes[i];
8262 dbtypes[i]=BLOB;
8263 field_types[i]=sha1_type_;
8264 dst_sizes[i]=CYCLUS_SHA1_SIZE;
8265
8266 }else if(valtype==typeid(boost::uuids::uuid)){
8267 shape=shapes[i];
8268 dbtypes[i]=UUID;
8269 hid_t item_type0;
8270 item_type0=uuid_type_;
8271 dst_sizes[i]=CYCLUS_UUID_SIZE;
8272 field_types[i]=item_type0;
8273
8274 }else if(valtype==typeid(std::vector<int>)){
8275 shape=shapes[i];
8276 if(shape.empty()||shape[0]<1){
8277 dbtypes[i]=VL_VECTOR_INT;
8278 hid_t item_type0;
8279 hid_t item_type1elem;
8280 item_type1elem=H5T_NATIVE_INT;
8281 item_type0=sha1_type_;
8282 if(vldts_.count(VL_VECTOR_INT)==0){
8283 vldts_[VL_VECTOR_INT]=H5Tvlen_create(item_type1elem);
8284 opened_types_.insert(vldts_[VL_VECTOR_INT]);
8285
8286 }
8287 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8288 field_types[i]=sha1_type_;
8289
8290 }else{
8291 dbtypes[i]=VECTOR_INT;
8292 hid_t item_type0;
8293 hsize_t shape01=shape[0];
8294 hid_t item_type1elem;
8295 item_type1elem=H5T_NATIVE_INT;
8296 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8297 dst_sizes[i]=((sizeof(int))*shape[0]);
8298 field_types[i]=item_type0;
8299 opened_types_.insert(field_types[i]);
8300
8301 }
8302
8303 }else if(valtype==typeid(std::vector<float>)){
8304 shape=shapes[i];
8305 if(shape.empty()||shape[0]<1){
8306 dbtypes[i]=VL_VECTOR_FLOAT;
8307 hid_t item_type0;
8308 hid_t item_type1elem;
8309 item_type1elem=H5T_NATIVE_FLOAT;
8310 item_type0=sha1_type_;
8311 if(vldts_.count(VL_VECTOR_FLOAT)==0){
8312 vldts_[VL_VECTOR_FLOAT]=H5Tvlen_create(item_type1elem);
8313 opened_types_.insert(vldts_[VL_VECTOR_FLOAT]);
8314
8315 }
8316 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8317 field_types[i]=sha1_type_;
8318
8319 }else{
8320 dbtypes[i]=VECTOR_FLOAT;
8321 hid_t item_type0;
8322 hsize_t shape01=shape[0];
8323 hid_t item_type1elem;
8324 item_type1elem=H5T_NATIVE_FLOAT;
8325 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8326 dst_sizes[i]=((sizeof(float))*shape[0]);
8327 field_types[i]=item_type0;
8328 opened_types_.insert(field_types[i]);
8329
8330 }
8331
8332 }else if(valtype==typeid(std::vector<double>)){
8333 shape=shapes[i];
8334 if(shape.empty()||shape[0]<1){
8335 dbtypes[i]=VL_VECTOR_DOUBLE;
8336 hid_t item_type0;
8337 hid_t item_type1elem;
8338 item_type1elem=H5T_NATIVE_DOUBLE;
8339 item_type0=sha1_type_;
8340 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
8341 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1elem);
8342 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
8343
8344 }
8345 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8346 field_types[i]=sha1_type_;
8347
8348 }else{
8349 dbtypes[i]=VECTOR_DOUBLE;
8350 hid_t item_type0;
8351 hsize_t shape01=shape[0];
8352 hid_t item_type1elem;
8353 item_type1elem=H5T_NATIVE_DOUBLE;
8354 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8355 dst_sizes[i]=((sizeof(double))*shape[0]);
8356 field_types[i]=item_type0;
8357 opened_types_.insert(field_types[i]);
8358
8359 }
8360
8361 }else if(valtype==typeid(std::vector<std::string>)){
8362 shape=shapes[i];
8363 if(shape.empty()||shape[0]<1&&shape[1]<1){
8364 dbtypes[i]=VL_VECTOR_VL_STRING;
8365 hid_t item_type0;
8366 hid_t item_type1elem;
8367 item_type1elem=sha1_type_;
8368 item_type0=sha1_type_;
8369 if(vldts_.count(VL_VECTOR_VL_STRING)==0){
8370 vldts_[VL_VECTOR_VL_STRING]=H5Tvlen_create(item_type1elem);
8371 opened_types_.insert(vldts_[VL_VECTOR_VL_STRING]);
8372
8373 }
8374 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8375 field_types[i]=sha1_type_;
8376
8377 }else if(shape[0]<1&&shape[1]>=1){
8378 dbtypes[i]=VL_VECTOR_STRING;
8379 hid_t item_type0;
8380 hid_t item_type1elem;
8381 item_type1elem=sha1_type_;
8382 item_type0=sha1_type_;
8383 if(vldts_.count(VL_VECTOR_STRING)==0){
8384 vldts_[VL_VECTOR_STRING]=H5Tvlen_create(item_type1elem);
8385 opened_types_.insert(vldts_[VL_VECTOR_STRING]);
8386
8387 }
8388 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8389 field_types[i]=sha1_type_;
8390
8391 }else if(shape[0]>=1&&shape[1]<1){
8392 dbtypes[i]=VECTOR_VL_STRING;
8393 hid_t item_type0;
8394 hsize_t shape01=shape[0];
8395 hid_t item_type1elem;
8396 item_type1elem=sha1_type_;
8397 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8398 dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8399 field_types[i]=item_type0;
8400 opened_types_.insert(field_types[i]);
8401
8402 }else{
8403 dbtypes[i]=VECTOR_STRING;
8404 hid_t item_type0;
8405 hsize_t shape01=shape[0];
8406 hid_t item_type1elem;
8407 item_type1elem=CreateFLStrType(shape[1]);
8408 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8409 dst_sizes[i]=((shape[1])*shape[0]);
8410 field_types[i]=item_type0;
8411 opened_types_.insert(field_types[i]);
8412
8413 }
8414
8415 }else if(valtype==typeid(std::vector<cyclus::Blob>)){
8416 shape=shapes[i];
8417 if(shape.empty()||shape[0]<1&&shape[1]<1){
8418 dbtypes[i]=VL_VECTOR_BLOB;
8419 hid_t item_type0;
8420 hid_t item_type1elem;
8421 item_type1elem=sha1_type_;
8422 item_type0=sha1_type_;
8423 if(vldts_.count(VL_VECTOR_BLOB)==0){
8424 vldts_[VL_VECTOR_BLOB]=H5Tvlen_create(item_type1elem);
8425 opened_types_.insert(vldts_[VL_VECTOR_BLOB]);
8426
8427 }
8428 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8429 field_types[i]=sha1_type_;
8430
8431 }else{
8432 dbtypes[i]=VECTOR_BLOB;
8433 hid_t item_type0;
8434 hsize_t shape01=shape[0];
8435 hid_t item_type1elem;
8436 item_type1elem=sha1_type_;
8437 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8438 dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8439 field_types[i]=item_type0;
8440 opened_types_.insert(field_types[i]);
8441
8442 }
8443
8444 }else if(valtype==typeid(std::vector<boost::uuids::uuid>)){
8445 shape=shapes[i];
8446 if(shape.empty()||shape[0]<1){
8447 dbtypes[i]=VL_VECTOR_UUID;
8448 hid_t item_type0;
8449 hid_t item_type1elem;
8450 item_type1elem=uuid_type_;
8451 item_type0=sha1_type_;
8452 if(vldts_.count(VL_VECTOR_UUID)==0){
8453 vldts_[VL_VECTOR_UUID]=H5Tvlen_create(item_type1elem);
8454 opened_types_.insert(vldts_[VL_VECTOR_UUID]);
8455
8456 }
8457 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8458 field_types[i]=sha1_type_;
8459
8460 }else{
8461 dbtypes[i]=VECTOR_UUID;
8462 hid_t item_type0;
8463 hsize_t shape01=shape[0];
8464 hid_t item_type1elem;
8465 item_type1elem=uuid_type_;
8466 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8467 dst_sizes[i]=((CYCLUS_UUID_SIZE)*shape[0]);
8468 field_types[i]=item_type0;
8469 opened_types_.insert(field_types[i]);
8470
8471 }
8472
8473 }else if(valtype==typeid(std::set<int>)){
8474 shape=shapes[i];
8475 if(shape.empty()||shape[0]<1){
8476 dbtypes[i]=VL_SET_INT;
8477 hid_t item_type0;
8478 hid_t item_type1elem;
8479 item_type1elem=H5T_NATIVE_INT;
8480 item_type0=sha1_type_;
8481 if(vldts_.count(VL_SET_INT)==0){
8482 vldts_[VL_SET_INT]=H5Tvlen_create(item_type1elem);
8483 opened_types_.insert(vldts_[VL_SET_INT]);
8484
8485 }
8486 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8487 field_types[i]=sha1_type_;
8488
8489 }else{
8490 dbtypes[i]=SET_INT;
8491 hid_t item_type0;
8492 hsize_t shape01=shape[0];
8493 hid_t item_type1elem;
8494 item_type1elem=H5T_NATIVE_INT;
8495 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8496 dst_sizes[i]=((sizeof(int))*shape[0]);
8497 field_types[i]=item_type0;
8498 opened_types_.insert(field_types[i]);
8499
8500 }
8501
8502 }else if(valtype==typeid(std::set<float>)){
8503 shape=shapes[i];
8504 if(shape.empty()||shape[0]<1){
8505 dbtypes[i]=VL_SET_FLOAT;
8506 hid_t item_type0;
8507 hid_t item_type1elem;
8508 item_type1elem=H5T_NATIVE_FLOAT;
8509 item_type0=sha1_type_;
8510 if(vldts_.count(VL_SET_FLOAT)==0){
8511 vldts_[VL_SET_FLOAT]=H5Tvlen_create(item_type1elem);
8512 opened_types_.insert(vldts_[VL_SET_FLOAT]);
8513
8514 }
8515 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8516 field_types[i]=sha1_type_;
8517
8518 }else{
8519 dbtypes[i]=SET_FLOAT;
8520 hid_t item_type0;
8521 hsize_t shape01=shape[0];
8522 hid_t item_type1elem;
8523 item_type1elem=H5T_NATIVE_FLOAT;
8524 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8525 dst_sizes[i]=((sizeof(float))*shape[0]);
8526 field_types[i]=item_type0;
8527 opened_types_.insert(field_types[i]);
8528
8529 }
8530
8531 }else if(valtype==typeid(std::set<double>)){
8532 shape=shapes[i];
8533 if(shape.empty()||shape[0]<1){
8534 dbtypes[i]=VL_SET_DOUBLE;
8535 hid_t item_type0;
8536 hid_t item_type1elem;
8537 item_type1elem=H5T_NATIVE_DOUBLE;
8538 item_type0=sha1_type_;
8539 if(vldts_.count(VL_SET_DOUBLE)==0){
8540 vldts_[VL_SET_DOUBLE]=H5Tvlen_create(item_type1elem);
8541 opened_types_.insert(vldts_[VL_SET_DOUBLE]);
8542
8543 }
8544 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8545 field_types[i]=sha1_type_;
8546
8547 }else{
8548 dbtypes[i]=SET_DOUBLE;
8549 hid_t item_type0;
8550 hsize_t shape01=shape[0];
8551 hid_t item_type1elem;
8552 item_type1elem=H5T_NATIVE_DOUBLE;
8553 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8554 dst_sizes[i]=((sizeof(double))*shape[0]);
8555 field_types[i]=item_type0;
8556 opened_types_.insert(field_types[i]);
8557
8558 }
8559
8560 }else if(valtype==typeid(std::set<std::string>)){
8561 shape=shapes[i];
8562 if(shape.empty()||shape[0]<1&&shape[1]<1){
8563 dbtypes[i]=VL_SET_VL_STRING;
8564 hid_t item_type0;
8565 hid_t item_type1elem;
8566 item_type1elem=sha1_type_;
8567 item_type0=sha1_type_;
8568 if(vldts_.count(VL_SET_VL_STRING)==0){
8569 vldts_[VL_SET_VL_STRING]=H5Tvlen_create(item_type1elem);
8570 opened_types_.insert(vldts_[VL_SET_VL_STRING]);
8571
8572 }
8573 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8574 field_types[i]=sha1_type_;
8575
8576 }else if(shape[0]<1&&shape[1]>=1){
8577 dbtypes[i]=VL_SET_STRING;
8578 hid_t item_type0;
8579 hid_t item_type1elem;
8580 item_type1elem=sha1_type_;
8581 item_type0=sha1_type_;
8582 if(vldts_.count(VL_SET_STRING)==0){
8583 vldts_[VL_SET_STRING]=H5Tvlen_create(item_type1elem);
8584 opened_types_.insert(vldts_[VL_SET_STRING]);
8585
8586 }
8587 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8588 field_types[i]=sha1_type_;
8589
8590 }else if(shape[0]>=1&&shape[1]<1){
8591 dbtypes[i]=SET_VL_STRING;
8592 hid_t item_type0;
8593 hsize_t shape01=shape[0];
8594 hid_t item_type1elem;
8595 item_type1elem=sha1_type_;
8596 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8597 dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8598 field_types[i]=item_type0;
8599 opened_types_.insert(field_types[i]);
8600
8601 }else{
8602 dbtypes[i]=SET_STRING;
8603 hid_t item_type0;
8604 hsize_t shape01=shape[0];
8605 hid_t item_type1elem;
8606 item_type1elem=CreateFLStrType(shape[1]);
8607 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8608 dst_sizes[i]=((shape[1])*shape[0]);
8609 field_types[i]=item_type0;
8610 opened_types_.insert(field_types[i]);
8611
8612 }
8613
8614 }else if(valtype==typeid(std::set<cyclus::Blob>)){
8615 shape=shapes[i];
8616 if(shape.empty()||shape[0]<1&&shape[1]<1){
8617 dbtypes[i]=VL_SET_BLOB;
8618 hid_t item_type0;
8619 hid_t item_type1elem;
8620 item_type1elem=sha1_type_;
8621 item_type0=sha1_type_;
8622 if(vldts_.count(VL_SET_BLOB)==0){
8623 vldts_[VL_SET_BLOB]=H5Tvlen_create(item_type1elem);
8624 opened_types_.insert(vldts_[VL_SET_BLOB]);
8625
8626 }
8627 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8628 field_types[i]=sha1_type_;
8629
8630 }else{
8631 dbtypes[i]=SET_BLOB;
8632 hid_t item_type0;
8633 hsize_t shape01=shape[0];
8634 hid_t item_type1elem;
8635 item_type1elem=sha1_type_;
8636 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8637 dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8638 field_types[i]=item_type0;
8639 opened_types_.insert(field_types[i]);
8640
8641 }
8642
8643 }else if(valtype==typeid(std::set<boost::uuids::uuid>)){
8644 shape=shapes[i];
8645 if(shape.empty()||shape[0]<1){
8646 dbtypes[i]=VL_SET_UUID;
8647 hid_t item_type0;
8648 hid_t item_type1elem;
8649 item_type1elem=uuid_type_;
8650 item_type0=sha1_type_;
8651 if(vldts_.count(VL_SET_UUID)==0){
8652 vldts_[VL_SET_UUID]=H5Tvlen_create(item_type1elem);
8653 opened_types_.insert(vldts_[VL_SET_UUID]);
8654
8655 }
8656 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8657 field_types[i]=sha1_type_;
8658
8659 }else{
8660 dbtypes[i]=SET_UUID;
8661 hid_t item_type0;
8662 hsize_t shape01=shape[0];
8663 hid_t item_type1elem;
8664 item_type1elem=uuid_type_;
8665 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8666 dst_sizes[i]=((CYCLUS_UUID_SIZE)*shape[0]);
8667 field_types[i]=item_type0;
8668 opened_types_.insert(field_types[i]);
8669
8670 }
8671
8672 }else if(valtype==typeid(std::list<bool>)){
8673 shape=shapes[i];
8674 if(shape.empty()||shape[0]<1){
8675 dbtypes[i]=VL_LIST_BOOL;
8676 hid_t item_type0;
8677 hid_t item_type1elem;
8678 item_type1elem=H5T_NATIVE_CHAR;
8679 item_type0=sha1_type_;
8680 if(vldts_.count(VL_LIST_BOOL)==0){
8681 vldts_[VL_LIST_BOOL]=H5Tvlen_create(item_type1elem);
8682 opened_types_.insert(vldts_[VL_LIST_BOOL]);
8683
8684 }
8685 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8686 field_types[i]=sha1_type_;
8687
8688 }else{
8689 dbtypes[i]=LIST_BOOL;
8690 hid_t item_type0;
8691 hsize_t shape01=shape[0];
8692 hid_t item_type1elem;
8693 item_type1elem=H5T_NATIVE_CHAR;
8694 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8695 dst_sizes[i]=((sizeof(char))*shape[0]);
8696 field_types[i]=item_type0;
8697 opened_types_.insert(field_types[i]);
8698
8699 }
8700
8701 }else if(valtype==typeid(std::list<int>)){
8702 shape=shapes[i];
8703 if(shape.empty()||shape[0]<1){
8704 dbtypes[i]=VL_LIST_INT;
8705 hid_t item_type0;
8706 hid_t item_type1elem;
8707 item_type1elem=H5T_NATIVE_INT;
8708 item_type0=sha1_type_;
8709 if(vldts_.count(VL_LIST_INT)==0){
8710 vldts_[VL_LIST_INT]=H5Tvlen_create(item_type1elem);
8711 opened_types_.insert(vldts_[VL_LIST_INT]);
8712
8713 }
8714 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8715 field_types[i]=sha1_type_;
8716
8717 }else{
8718 dbtypes[i]=LIST_INT;
8719 hid_t item_type0;
8720 hsize_t shape01=shape[0];
8721 hid_t item_type1elem;
8722 item_type1elem=H5T_NATIVE_INT;
8723 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8724 dst_sizes[i]=((sizeof(int))*shape[0]);
8725 field_types[i]=item_type0;
8726 opened_types_.insert(field_types[i]);
8727
8728 }
8729
8730 }else if(valtype==typeid(std::list<float>)){
8731 shape=shapes[i];
8732 if(shape.empty()||shape[0]<1){
8733 dbtypes[i]=VL_LIST_FLOAT;
8734 hid_t item_type0;
8735 hid_t item_type1elem;
8736 item_type1elem=H5T_NATIVE_FLOAT;
8737 item_type0=sha1_type_;
8738 if(vldts_.count(VL_LIST_FLOAT)==0){
8739 vldts_[VL_LIST_FLOAT]=H5Tvlen_create(item_type1elem);
8740 opened_types_.insert(vldts_[VL_LIST_FLOAT]);
8741
8742 }
8743 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8744 field_types[i]=sha1_type_;
8745
8746 }else{
8747 dbtypes[i]=LIST_FLOAT;
8748 hid_t item_type0;
8749 hsize_t shape01=shape[0];
8750 hid_t item_type1elem;
8751 item_type1elem=H5T_NATIVE_FLOAT;
8752 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8753 dst_sizes[i]=((sizeof(float))*shape[0]);
8754 field_types[i]=item_type0;
8755 opened_types_.insert(field_types[i]);
8756
8757 }
8758
8759 }else if(valtype==typeid(std::list<double>)){
8760 shape=shapes[i];
8761 if(shape.empty()||shape[0]<1){
8762 dbtypes[i]=VL_LIST_DOUBLE;
8763 hid_t item_type0;
8764 hid_t item_type1elem;
8765 item_type1elem=H5T_NATIVE_DOUBLE;
8766 item_type0=sha1_type_;
8767 if(vldts_.count(VL_LIST_DOUBLE)==0){
8768 vldts_[VL_LIST_DOUBLE]=H5Tvlen_create(item_type1elem);
8769 opened_types_.insert(vldts_[VL_LIST_DOUBLE]);
8770
8771 }
8772 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8773 field_types[i]=sha1_type_;
8774
8775 }else{
8776 dbtypes[i]=LIST_DOUBLE;
8777 hid_t item_type0;
8778 hsize_t shape01=shape[0];
8779 hid_t item_type1elem;
8780 item_type1elem=H5T_NATIVE_DOUBLE;
8781 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8782 dst_sizes[i]=((sizeof(double))*shape[0]);
8783 field_types[i]=item_type0;
8784 opened_types_.insert(field_types[i]);
8785
8786 }
8787
8788 }else if(valtype==typeid(std::list<std::string>)){
8789 shape=shapes[i];
8790 if(shape.empty()||shape[0]<1&&shape[1]<1){
8791 dbtypes[i]=VL_LIST_VL_STRING;
8792 hid_t item_type0;
8793 hid_t item_type1elem;
8794 item_type1elem=sha1_type_;
8795 item_type0=sha1_type_;
8796 if(vldts_.count(VL_LIST_VL_STRING)==0){
8797 vldts_[VL_LIST_VL_STRING]=H5Tvlen_create(item_type1elem);
8798 opened_types_.insert(vldts_[VL_LIST_VL_STRING]);
8799
8800 }
8801 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8802 field_types[i]=sha1_type_;
8803
8804 }else if(shape[0]<1&&shape[1]>=1){
8805 dbtypes[i]=VL_LIST_STRING;
8806 hid_t item_type0;
8807 hid_t item_type1elem;
8808 item_type1elem=sha1_type_;
8809 item_type0=sha1_type_;
8810 if(vldts_.count(VL_LIST_STRING)==0){
8811 vldts_[VL_LIST_STRING]=H5Tvlen_create(item_type1elem);
8812 opened_types_.insert(vldts_[VL_LIST_STRING]);
8813
8814 }
8815 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8816 field_types[i]=sha1_type_;
8817
8818 }else if(shape[0]>=1&&shape[1]<1){
8819 dbtypes[i]=LIST_VL_STRING;
8820 hid_t item_type0;
8821 hsize_t shape01=shape[0];
8822 hid_t item_type1elem;
8823 item_type1elem=sha1_type_;
8824 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8825 dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8826 field_types[i]=item_type0;
8827 opened_types_.insert(field_types[i]);
8828
8829 }else{
8830 dbtypes[i]=LIST_STRING;
8831 hid_t item_type0;
8832 hsize_t shape01=shape[0];
8833 hid_t item_type1elem;
8834 item_type1elem=CreateFLStrType(shape[1]);
8835 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8836 dst_sizes[i]=((shape[1])*shape[0]);
8837 field_types[i]=item_type0;
8838 opened_types_.insert(field_types[i]);
8839
8840 }
8841
8842 }else if(valtype==typeid(std::list<cyclus::Blob>)){
8843 shape=shapes[i];
8844 if(shape.empty()||shape[0]<1&&shape[1]<1){
8845 dbtypes[i]=VL_LIST_BLOB;
8846 hid_t item_type0;
8847 hid_t item_type1elem;
8848 item_type1elem=sha1_type_;
8849 item_type0=sha1_type_;
8850 if(vldts_.count(VL_LIST_BLOB)==0){
8851 vldts_[VL_LIST_BLOB]=H5Tvlen_create(item_type1elem);
8852 opened_types_.insert(vldts_[VL_LIST_BLOB]);
8853
8854 }
8855 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8856 field_types[i]=sha1_type_;
8857
8858 }else{
8859 dbtypes[i]=LIST_BLOB;
8860 hid_t item_type0;
8861 hsize_t shape01=shape[0];
8862 hid_t item_type1elem;
8863 item_type1elem=sha1_type_;
8864 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8865 dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8866 field_types[i]=item_type0;
8867 opened_types_.insert(field_types[i]);
8868
8869 }
8870
8871 }else if(valtype==typeid(std::list<boost::uuids::uuid>)){
8872 shape=shapes[i];
8873 if(shape.empty()||shape[0]<1){
8874 dbtypes[i]=VL_LIST_UUID;
8875 hid_t item_type0;
8876 hid_t item_type1elem;
8877 item_type1elem=uuid_type_;
8878 item_type0=sha1_type_;
8879 if(vldts_.count(VL_LIST_UUID)==0){
8880 vldts_[VL_LIST_UUID]=H5Tvlen_create(item_type1elem);
8881 opened_types_.insert(vldts_[VL_LIST_UUID]);
8882
8883 }
8884 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8885 field_types[i]=sha1_type_;
8886
8887 }else{
8888 dbtypes[i]=LIST_UUID;
8889 hid_t item_type0;
8890 hsize_t shape01=shape[0];
8891 hid_t item_type1elem;
8892 item_type1elem=uuid_type_;
8893 item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8894 dst_sizes[i]=((CYCLUS_UUID_SIZE)*shape[0]);
8895 field_types[i]=item_type0;
8896 opened_types_.insert(field_types[i]);
8897
8898 }
8899
8900 }else if(valtype==typeid(std::pair<int, bool>)){
8901 shape=shapes[i];
8902 dbtypes[i]=PAIR_INT_BOOL;
8903 hid_t item_type0;
8904 hid_t item_type1first;
8905 item_type1first=H5T_NATIVE_INT;
8906 hid_t item_type1second;
8907 item_type1second=H5T_NATIVE_CHAR;
8908 hid_t item_type1compound;
8909 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(char));
8910 H5Tinsert(item_type1compound, "first", 0, item_type1first);
8911 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8912 dst_sizes[i]=((sizeof(int)+sizeof(char)));
8913 field_types[i]=item_type1compound;
8914 opened_types_.insert(field_types[i]);
8915
8916 }else if(valtype==typeid(std::pair<int, int>)){
8917 shape=shapes[i];
8918 dbtypes[i]=PAIR_INT_INT;
8919 hid_t item_type0;
8920 hid_t item_type1first;
8921 item_type1first=H5T_NATIVE_INT;
8922 hid_t item_type1second;
8923 item_type1second=H5T_NATIVE_INT;
8924 hid_t item_type1compound;
8925 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
8926 H5Tinsert(item_type1compound, "first", 0, item_type1first);
8927 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8928 dst_sizes[i]=((sizeof(int)+sizeof(int)));
8929 field_types[i]=item_type1compound;
8930 opened_types_.insert(field_types[i]);
8931
8932 }else if(valtype==typeid(std::pair<int, float>)){
8933 shape=shapes[i];
8934 dbtypes[i]=PAIR_INT_FLOAT;
8935 hid_t item_type0;
8936 hid_t item_type1first;
8937 item_type1first=H5T_NATIVE_INT;
8938 hid_t item_type1second;
8939 item_type1second=H5T_NATIVE_FLOAT;
8940 hid_t item_type1compound;
8941 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(float));
8942 H5Tinsert(item_type1compound, "first", 0, item_type1first);
8943 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8944 dst_sizes[i]=((sizeof(int)+sizeof(float)));
8945 field_types[i]=item_type1compound;
8946 opened_types_.insert(field_types[i]);
8947
8948 }else if(valtype==typeid(std::pair<int, double>)){
8949 shape=shapes[i];
8950 dbtypes[i]=PAIR_INT_DOUBLE;
8951 hid_t item_type0;
8952 hid_t item_type1first;
8953 item_type1first=H5T_NATIVE_INT;
8954 hid_t item_type1second;
8955 item_type1second=H5T_NATIVE_DOUBLE;
8956 hid_t item_type1compound;
8957 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
8958 H5Tinsert(item_type1compound, "first", 0, item_type1first);
8959 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8960 dst_sizes[i]=((sizeof(int)+sizeof(double)));
8961 field_types[i]=item_type1compound;
8962 opened_types_.insert(field_types[i]);
8963
8964 }else if(valtype==typeid(std::pair<int, std::string>)){
8965 shape=shapes[i];
8966 if(shape.empty()||shape[2]<1){
8967 dbtypes[i]=PAIR_INT_VL_STRING;
8968 hid_t item_type0;
8969 hid_t item_type1first;
8970 item_type1first=H5T_NATIVE_INT;
8971 hid_t item_type1second;
8972 item_type1second=sha1_type_;
8973 hid_t item_type1compound;
8974 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
8975 H5Tinsert(item_type1compound, "first", 0, item_type1first);
8976 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8977 dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE));
8978 field_types[i]=item_type1compound;
8979 opened_types_.insert(field_types[i]);
8980
8981 }else{
8982 dbtypes[i]=PAIR_INT_STRING;
8983 hid_t item_type0;
8984 hid_t item_type1first;
8985 item_type1first=H5T_NATIVE_INT;
8986 hid_t item_type1second;
8987 item_type1second=CreateFLStrType(shape[2]);
8988 hid_t item_type1compound;
8989 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+shape[2]);
8990 H5Tinsert(item_type1compound, "first", 0, item_type1first);
8991 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8992 dst_sizes[i]=((sizeof(int)+shape[2]));
8993 field_types[i]=item_type1compound;
8994 opened_types_.insert(field_types[i]);
8995
8996 }
8997
8998 }else if(valtype==typeid(std::pair<int, cyclus::Blob>)){
8999 shape=shapes[i];
9000 dbtypes[i]=PAIR_INT_BLOB;
9001 hid_t item_type0;
9002 hid_t item_type1first;
9003 item_type1first=H5T_NATIVE_INT;
9004 hid_t item_type1second;
9005 item_type1second=sha1_type_;
9006 hid_t item_type1compound;
9007 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9008 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9009 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
9010 dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE));
9011 field_types[i]=item_type1compound;
9012 opened_types_.insert(field_types[i]);
9013
9014 }else if(valtype==typeid(std::pair<int, boost::uuids::uuid>)){
9015 shape=shapes[i];
9016 dbtypes[i]=PAIR_INT_UUID;
9017 hid_t item_type0;
9018 hid_t item_type1first;
9019 item_type1first=H5T_NATIVE_INT;
9020 hid_t item_type1second;
9021 item_type1second=uuid_type_;
9022 hid_t item_type1compound;
9023 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_UUID_SIZE);
9024 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9025 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
9026 dst_sizes[i]=((sizeof(int)+CYCLUS_UUID_SIZE));
9027 field_types[i]=item_type1compound;
9028 opened_types_.insert(field_types[i]);
9029
9030 }else if(valtype==typeid(std::pair<std::string, bool>)){
9031 shape=shapes[i];
9032 if(shape.empty()||shape[1]<1){
9033 dbtypes[i]=PAIR_VL_STRING_BOOL;
9034 hid_t item_type0;
9035 hid_t item_type1first;
9036 item_type1first=sha1_type_;
9037 hid_t item_type1second;
9038 item_type1second=H5T_NATIVE_CHAR;
9039 hid_t item_type1compound;
9040 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9041 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9042 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9043 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(char)));
9044 field_types[i]=item_type1compound;
9045 opened_types_.insert(field_types[i]);
9046
9047 }else{
9048 dbtypes[i]=PAIR_STRING_BOOL;
9049 hid_t item_type0;
9050 hid_t item_type1first;
9051 item_type1first=CreateFLStrType(shape[1]);
9052 hid_t item_type1second;
9053 item_type1second=H5T_NATIVE_CHAR;
9054 hid_t item_type1compound;
9055 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(char));
9056 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9057 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9058 dst_sizes[i]=((shape[1]+sizeof(char)));
9059 field_types[i]=item_type1compound;
9060 opened_types_.insert(field_types[i]);
9061
9062 }
9063
9064 }else if(valtype==typeid(std::pair<std::string, int>)){
9065 shape=shapes[i];
9066 if(shape.empty()||shape[1]<1){
9067 dbtypes[i]=PAIR_VL_STRING_INT;
9068 hid_t item_type0;
9069 hid_t item_type1first;
9070 item_type1first=sha1_type_;
9071 hid_t item_type1second;
9072 item_type1second=H5T_NATIVE_INT;
9073 hid_t item_type1compound;
9074 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9075 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9076 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9077 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(int)));
9078 field_types[i]=item_type1compound;
9079 opened_types_.insert(field_types[i]);
9080
9081 }else{
9082 dbtypes[i]=PAIR_STRING_INT;
9083 hid_t item_type0;
9084 hid_t item_type1first;
9085 item_type1first=CreateFLStrType(shape[1]);
9086 hid_t item_type1second;
9087 item_type1second=H5T_NATIVE_INT;
9088 hid_t item_type1compound;
9089 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(int));
9090 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9091 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9092 dst_sizes[i]=((shape[1]+sizeof(int)));
9093 field_types[i]=item_type1compound;
9094 opened_types_.insert(field_types[i]);
9095
9096 }
9097
9098 }else if(valtype==typeid(std::pair<std::string, float>)){
9099 shape=shapes[i];
9100 if(shape.empty()||shape[1]<1){
9101 dbtypes[i]=PAIR_VL_STRING_FLOAT;
9102 hid_t item_type0;
9103 hid_t item_type1first;
9104 item_type1first=sha1_type_;
9105 hid_t item_type1second;
9106 item_type1second=H5T_NATIVE_FLOAT;
9107 hid_t item_type1compound;
9108 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9109 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9110 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9111 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(float)));
9112 field_types[i]=item_type1compound;
9113 opened_types_.insert(field_types[i]);
9114
9115 }else{
9116 dbtypes[i]=PAIR_STRING_FLOAT;
9117 hid_t item_type0;
9118 hid_t item_type1first;
9119 item_type1first=CreateFLStrType(shape[1]);
9120 hid_t item_type1second;
9121 item_type1second=H5T_NATIVE_FLOAT;
9122 hid_t item_type1compound;
9123 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(float));
9124 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9125 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9126 dst_sizes[i]=((shape[1]+sizeof(float)));
9127 field_types[i]=item_type1compound;
9128 opened_types_.insert(field_types[i]);
9129
9130 }
9131
9132 }else if(valtype==typeid(std::pair<std::string, double>)){
9133 shape=shapes[i];
9134 if(shape.empty()||shape[1]<1){
9135 dbtypes[i]=PAIR_VL_STRING_DOUBLE;
9136 hid_t item_type0;
9137 hid_t item_type1first;
9138 item_type1first=sha1_type_;
9139 hid_t item_type1second;
9140 item_type1second=H5T_NATIVE_DOUBLE;
9141 hid_t item_type1compound;
9142 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9143 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9144 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9145 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(double)));
9146 field_types[i]=item_type1compound;
9147 opened_types_.insert(field_types[i]);
9148
9149 }else{
9150 dbtypes[i]=PAIR_STRING_DOUBLE;
9151 hid_t item_type0;
9152 hid_t item_type1first;
9153 item_type1first=CreateFLStrType(shape[1]);
9154 hid_t item_type1second;
9155 item_type1second=H5T_NATIVE_DOUBLE;
9156 hid_t item_type1compound;
9157 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(double));
9158 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9159 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9160 dst_sizes[i]=((shape[1]+sizeof(double)));
9161 field_types[i]=item_type1compound;
9162 opened_types_.insert(field_types[i]);
9163
9164 }
9165
9166 }else if(valtype==typeid(std::pair<std::string, std::string>)){
9167 shape=shapes[i];
9168 if(shape.empty()||shape[1]<1&&shape[2]<1){
9169 dbtypes[i]=PAIR_VL_STRING_VL_STRING;
9170 hid_t item_type0;
9171 hid_t item_type1first;
9172 item_type1first=sha1_type_;
9173 hid_t item_type1second;
9174 item_type1second=sha1_type_;
9175 hid_t item_type1compound;
9176 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9177 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9178 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9179 dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
9180 field_types[i]=item_type1compound;
9181 opened_types_.insert(field_types[i]);
9182
9183 }else if(shape[1]>=1&&shape[2]<1){
9184 dbtypes[i]=PAIR_STRING_VL_STRING;
9185 hid_t item_type0;
9186 hid_t item_type1first;
9187 item_type1first=CreateFLStrType(shape[1]);
9188 hid_t item_type1second;
9189 item_type1second=sha1_type_;
9190 hid_t item_type1compound;
9191 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
9192 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9193 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9194 dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE));
9195 field_types[i]=item_type1compound;
9196 opened_types_.insert(field_types[i]);
9197
9198 }else if(shape[1]<1&&shape[2]>=1){
9199 dbtypes[i]=PAIR_VL_STRING_STRING;
9200 hid_t item_type0;
9201 hid_t item_type1first;
9202 item_type1first=sha1_type_;
9203 hid_t item_type1second;
9204 item_type1second=CreateFLStrType(shape[2]);
9205 hid_t item_type1compound;
9206 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[2]);
9207 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9208 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9209 dst_sizes[i]=((CYCLUS_SHA1_SIZE+shape[2]));
9210 field_types[i]=item_type1compound;
9211 opened_types_.insert(field_types[i]);
9212
9213 }else{
9214 dbtypes[i]=PAIR_STRING_STRING;
9215 hid_t item_type0;
9216 hid_t item_type1first;
9217 item_type1first=CreateFLStrType(shape[1]);
9218 hid_t item_type1second;
9219 item_type1second=CreateFLStrType(shape[2]);
9220 hid_t item_type1compound;
9221 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+shape[2]);
9222 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9223 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9224 dst_sizes[i]=((shape[1]+shape[2]));
9225 field_types[i]=item_type1compound;
9226 opened_types_.insert(field_types[i]);
9227
9228 }
9229
9230 }else if(valtype==typeid(std::pair<std::string, cyclus::Blob>)){
9231 shape=shapes[i];
9232 if(shape.empty()||shape[1]<1&&shape[2]<1){
9233 dbtypes[i]=PAIR_VL_STRING_BLOB;
9234 hid_t item_type0;
9235 hid_t item_type1first;
9236 item_type1first=sha1_type_;
9237 hid_t item_type1second;
9238 item_type1second=sha1_type_;
9239 hid_t item_type1compound;
9240 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9241 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9242 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9243 dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
9244 field_types[i]=item_type1compound;
9245 opened_types_.insert(field_types[i]);
9246
9247 }else{
9248 dbtypes[i]=PAIR_STRING_BLOB;
9249 hid_t item_type0;
9250 hid_t item_type1first;
9251 item_type1first=CreateFLStrType(shape[1]);
9252 hid_t item_type1second;
9253 item_type1second=sha1_type_;
9254 hid_t item_type1compound;
9255 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
9256 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9257 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9258 dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE));
9259 field_types[i]=item_type1compound;
9260 opened_types_.insert(field_types[i]);
9261
9262 }
9263
9264 }else if(valtype==typeid(std::pair<std::string, boost::uuids::uuid>)){
9265 shape=shapes[i];
9266 if(shape.empty()||shape[1]<1){
9267 dbtypes[i]=PAIR_VL_STRING_UUID;
9268 hid_t item_type0;
9269 hid_t item_type1first;
9270 item_type1first=sha1_type_;
9271 hid_t item_type1second;
9272 item_type1second=uuid_type_;
9273 hid_t item_type1compound;
9274 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
9275 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9276 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9277 dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE));
9278 field_types[i]=item_type1compound;
9279 opened_types_.insert(field_types[i]);
9280
9281 }else{
9282 dbtypes[i]=PAIR_STRING_UUID;
9283 hid_t item_type0;
9284 hid_t item_type1first;
9285 item_type1first=CreateFLStrType(shape[1]);
9286 hid_t item_type1second;
9287 item_type1second=uuid_type_;
9288 hid_t item_type1compound;
9289 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_UUID_SIZE);
9290 H5Tinsert(item_type1compound, "first", 0, item_type1first);
9291 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9292 dst_sizes[i]=((shape[1]+CYCLUS_UUID_SIZE));
9293 field_types[i]=item_type1compound;
9294 opened_types_.insert(field_types[i]);
9295
9296 }
9297
9298 }else if(valtype==typeid(std::map<int, bool>)){
9299 shape=shapes[i];
9300 if(shape.empty()||shape[0]<1){
9301 dbtypes[i]=VL_MAP_INT_BOOL;
9302 hid_t item_type0;
9303 hid_t item_type1key;
9304 item_type1key=H5T_NATIVE_INT;
9305 hid_t item_type1val;
9306 item_type1val=H5T_NATIVE_CHAR;
9307 hid_t item_type1compound;
9308 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(char));
9309 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9310 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9311 item_type0=sha1_type_;
9312 if(vldts_.count(VL_MAP_INT_BOOL)==0){
9313 vldts_[VL_MAP_INT_BOOL]=H5Tvlen_create(item_type1compound);
9314 opened_types_.insert(vldts_[VL_MAP_INT_BOOL]);
9315
9316 }
9317 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9318 field_types[i]=sha1_type_;
9319
9320 }else{
9321 dbtypes[i]=MAP_INT_BOOL;
9322 hid_t item_type0;
9323 hsize_t shape01=shape[0];
9324 hid_t item_type1key;
9325 item_type1key=H5T_NATIVE_INT;
9326 hid_t item_type1val;
9327 item_type1val=H5T_NATIVE_CHAR;
9328 hid_t item_type1compound;
9329 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(char));
9330 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9331 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9332 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9333 dst_sizes[i]=((sizeof(int)+sizeof(char))*shape[0]);
9334 field_types[i]=item_type0;
9335 opened_types_.insert(item_type1compound);
9336 opened_types_.insert(field_types[i]);
9337
9338 }
9339
9340 }else if(valtype==typeid(std::map<int, int>)){
9341 shape=shapes[i];
9342 if(shape.empty()||shape[0]<1){
9343 dbtypes[i]=VL_MAP_INT_INT;
9344 hid_t item_type0;
9345 hid_t item_type1key;
9346 item_type1key=H5T_NATIVE_INT;
9347 hid_t item_type1val;
9348 item_type1val=H5T_NATIVE_INT;
9349 hid_t item_type1compound;
9350 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
9351 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9352 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9353 item_type0=sha1_type_;
9354 if(vldts_.count(VL_MAP_INT_INT)==0){
9355 vldts_[VL_MAP_INT_INT]=H5Tvlen_create(item_type1compound);
9356 opened_types_.insert(vldts_[VL_MAP_INT_INT]);
9357
9358 }
9359 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9360 field_types[i]=sha1_type_;
9361
9362 }else{
9363 dbtypes[i]=MAP_INT_INT;
9364 hid_t item_type0;
9365 hsize_t shape01=shape[0];
9366 hid_t item_type1key;
9367 item_type1key=H5T_NATIVE_INT;
9368 hid_t item_type1val;
9369 item_type1val=H5T_NATIVE_INT;
9370 hid_t item_type1compound;
9371 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
9372 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9373 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9374 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9375 dst_sizes[i]=((sizeof(int)+sizeof(int))*shape[0]);
9376 field_types[i]=item_type0;
9377 opened_types_.insert(item_type1compound);
9378 opened_types_.insert(field_types[i]);
9379
9380 }
9381
9382 }else if(valtype==typeid(std::map<int, float>)){
9383 shape=shapes[i];
9384 if(shape.empty()||shape[0]<1){
9385 dbtypes[i]=VL_MAP_INT_FLOAT;
9386 hid_t item_type0;
9387 hid_t item_type1key;
9388 item_type1key=H5T_NATIVE_INT;
9389 hid_t item_type1val;
9390 item_type1val=H5T_NATIVE_FLOAT;
9391 hid_t item_type1compound;
9392 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(float));
9393 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9394 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9395 item_type0=sha1_type_;
9396 if(vldts_.count(VL_MAP_INT_FLOAT)==0){
9397 vldts_[VL_MAP_INT_FLOAT]=H5Tvlen_create(item_type1compound);
9398 opened_types_.insert(vldts_[VL_MAP_INT_FLOAT]);
9399
9400 }
9401 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9402 field_types[i]=sha1_type_;
9403
9404 }else{
9405 dbtypes[i]=MAP_INT_FLOAT;
9406 hid_t item_type0;
9407 hsize_t shape01=shape[0];
9408 hid_t item_type1key;
9409 item_type1key=H5T_NATIVE_INT;
9410 hid_t item_type1val;
9411 item_type1val=H5T_NATIVE_FLOAT;
9412 hid_t item_type1compound;
9413 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(float));
9414 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9415 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9416 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9417 dst_sizes[i]=((sizeof(int)+sizeof(float))*shape[0]);
9418 field_types[i]=item_type0;
9419 opened_types_.insert(item_type1compound);
9420 opened_types_.insert(field_types[i]);
9421
9422 }
9423
9424 }else if(valtype==typeid(std::map<int, double>)){
9425 shape=shapes[i];
9426 if(shape.empty()||shape[0]<1){
9427 dbtypes[i]=VL_MAP_INT_DOUBLE;
9428 hid_t item_type0;
9429 hid_t item_type1key;
9430 item_type1key=H5T_NATIVE_INT;
9431 hid_t item_type1val;
9432 item_type1val=H5T_NATIVE_DOUBLE;
9433 hid_t item_type1compound;
9434 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
9435 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9436 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9437 item_type0=sha1_type_;
9438 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
9439 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
9440 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
9441
9442 }
9443 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9444 field_types[i]=sha1_type_;
9445
9446 }else{
9447 dbtypes[i]=MAP_INT_DOUBLE;
9448 hid_t item_type0;
9449 hsize_t shape01=shape[0];
9450 hid_t item_type1key;
9451 item_type1key=H5T_NATIVE_INT;
9452 hid_t item_type1val;
9453 item_type1val=H5T_NATIVE_DOUBLE;
9454 hid_t item_type1compound;
9455 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
9456 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9457 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9458 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9459 dst_sizes[i]=((sizeof(int)+sizeof(double))*shape[0]);
9460 field_types[i]=item_type0;
9461 opened_types_.insert(item_type1compound);
9462 opened_types_.insert(field_types[i]);
9463
9464 }
9465
9466 }else if(valtype==typeid(std::map<int, std::string>)){
9467 shape=shapes[i];
9468 if(shape.empty()||shape[0]<1&&shape[2]<1){
9469 dbtypes[i]=VL_MAP_INT_VL_STRING;
9470 hid_t item_type0;
9471 hid_t item_type1key;
9472 item_type1key=H5T_NATIVE_INT;
9473 hid_t item_type1val;
9474 item_type1val=sha1_type_;
9475 hid_t item_type1compound;
9476 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9477 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9478 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9479 item_type0=sha1_type_;
9480 if(vldts_.count(VL_MAP_INT_VL_STRING)==0){
9481 vldts_[VL_MAP_INT_VL_STRING]=H5Tvlen_create(item_type1compound);
9482 opened_types_.insert(vldts_[VL_MAP_INT_VL_STRING]);
9483
9484 }
9485 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9486 field_types[i]=sha1_type_;
9487
9488 }else if(shape[0]<1&&shape[2]>=1){
9489 dbtypes[i]=VL_MAP_INT_STRING;
9490 hid_t item_type0;
9491 hid_t item_type1key;
9492 item_type1key=H5T_NATIVE_INT;
9493 hid_t item_type1val;
9494 item_type1val=sha1_type_;
9495 hid_t item_type1compound;
9496 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9497 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9498 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9499 item_type0=sha1_type_;
9500 if(vldts_.count(VL_MAP_INT_STRING)==0){
9501 vldts_[VL_MAP_INT_STRING]=H5Tvlen_create(item_type1compound);
9502 opened_types_.insert(vldts_[VL_MAP_INT_STRING]);
9503
9504 }
9505 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9506 field_types[i]=sha1_type_;
9507
9508 }else if(shape[0]>=1&&shape[2]<1){
9509 dbtypes[i]=MAP_INT_VL_STRING;
9510 hid_t item_type0;
9511 hsize_t shape01=shape[0];
9512 hid_t item_type1key;
9513 item_type1key=H5T_NATIVE_INT;
9514 hid_t item_type1val;
9515 item_type1val=sha1_type_;
9516 hid_t item_type1compound;
9517 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9518 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9519 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9520 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9521 dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
9522 field_types[i]=item_type0;
9523 opened_types_.insert(item_type1compound);
9524 opened_types_.insert(field_types[i]);
9525
9526 }else{
9527 dbtypes[i]=MAP_INT_STRING;
9528 hid_t item_type0;
9529 hsize_t shape01=shape[0];
9530 hid_t item_type1key;
9531 item_type1key=H5T_NATIVE_INT;
9532 hid_t item_type1val;
9533 item_type1val=CreateFLStrType(shape[2]);
9534 hid_t item_type1compound;
9535 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+shape[2]);
9536 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9537 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9538 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9539 dst_sizes[i]=((sizeof(int)+shape[2])*shape[0]);
9540 field_types[i]=item_type0;
9541 opened_types_.insert(item_type1compound);
9542 opened_types_.insert(field_types[i]);
9543
9544 }
9545
9546 }else if(valtype==typeid(std::map<int, cyclus::Blob>)){
9547 shape=shapes[i];
9548 if(shape.empty()||shape[0]<1&&shape[2]<1){
9549 dbtypes[i]=VL_MAP_INT_BLOB;
9550 hid_t item_type0;
9551 hid_t item_type1key;
9552 item_type1key=H5T_NATIVE_INT;
9553 hid_t item_type1val;
9554 item_type1val=sha1_type_;
9555 hid_t item_type1compound;
9556 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9557 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9558 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9559 item_type0=sha1_type_;
9560 if(vldts_.count(VL_MAP_INT_BLOB)==0){
9561 vldts_[VL_MAP_INT_BLOB]=H5Tvlen_create(item_type1compound);
9562 opened_types_.insert(vldts_[VL_MAP_INT_BLOB]);
9563
9564 }
9565 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9566 field_types[i]=sha1_type_;
9567
9568 }else{
9569 dbtypes[i]=MAP_INT_BLOB;
9570 hid_t item_type0;
9571 hsize_t shape01=shape[0];
9572 hid_t item_type1key;
9573 item_type1key=H5T_NATIVE_INT;
9574 hid_t item_type1val;
9575 item_type1val=sha1_type_;
9576 hid_t item_type1compound;
9577 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9578 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9579 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9580 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9581 dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
9582 field_types[i]=item_type0;
9583 opened_types_.insert(item_type1compound);
9584 opened_types_.insert(field_types[i]);
9585
9586 }
9587
9588 }else if(valtype==typeid(std::map<int, boost::uuids::uuid>)){
9589 shape=shapes[i];
9590 if(shape.empty()||shape[0]<1){
9591 dbtypes[i]=VL_MAP_INT_UUID;
9592 hid_t item_type0;
9593 hid_t item_type1key;
9594 item_type1key=H5T_NATIVE_INT;
9595 hid_t item_type1val;
9596 item_type1val=uuid_type_;
9597 hid_t item_type1compound;
9598 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_UUID_SIZE);
9599 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9600 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9601 item_type0=sha1_type_;
9602 if(vldts_.count(VL_MAP_INT_UUID)==0){
9603 vldts_[VL_MAP_INT_UUID]=H5Tvlen_create(item_type1compound);
9604 opened_types_.insert(vldts_[VL_MAP_INT_UUID]);
9605
9606 }
9607 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9608 field_types[i]=sha1_type_;
9609
9610 }else{
9611 dbtypes[i]=MAP_INT_UUID;
9612 hid_t item_type0;
9613 hsize_t shape01=shape[0];
9614 hid_t item_type1key;
9615 item_type1key=H5T_NATIVE_INT;
9616 hid_t item_type1val;
9617 item_type1val=uuid_type_;
9618 hid_t item_type1compound;
9619 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_UUID_SIZE);
9620 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9621 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9622 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9623 dst_sizes[i]=((sizeof(int)+CYCLUS_UUID_SIZE)*shape[0]);
9624 field_types[i]=item_type0;
9625 opened_types_.insert(item_type1compound);
9626 opened_types_.insert(field_types[i]);
9627
9628 }
9629
9630 }else if(valtype==typeid(std::map<std::string, bool>)){
9631 shape=shapes[i];
9632 if(shape.empty()||shape[0]<1&&shape[1]<1){
9633 dbtypes[i]=VL_MAP_VL_STRING_BOOL;
9634 hid_t item_type0;
9635 hid_t item_type1key;
9636 item_type1key=sha1_type_;
9637 hid_t item_type1val;
9638 item_type1val=H5T_NATIVE_CHAR;
9639 hid_t item_type1compound;
9640 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9641 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9642 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9643 item_type0=sha1_type_;
9644 if(vldts_.count(VL_MAP_VL_STRING_BOOL)==0){
9645 vldts_[VL_MAP_VL_STRING_BOOL]=H5Tvlen_create(item_type1compound);
9646 opened_types_.insert(vldts_[VL_MAP_VL_STRING_BOOL]);
9647
9648 }
9649 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9650 field_types[i]=sha1_type_;
9651
9652 }else if(shape[0]<1&&shape[1]>=1){
9653 dbtypes[i]=VL_MAP_STRING_BOOL;
9654 hid_t item_type0;
9655 hid_t item_type1key;
9656 item_type1key=sha1_type_;
9657 hid_t item_type1val;
9658 item_type1val=H5T_NATIVE_CHAR;
9659 hid_t item_type1compound;
9660 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9661 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9662 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9663 item_type0=sha1_type_;
9664 if(vldts_.count(VL_MAP_STRING_BOOL)==0){
9665 vldts_[VL_MAP_STRING_BOOL]=H5Tvlen_create(item_type1compound);
9666 opened_types_.insert(vldts_[VL_MAP_STRING_BOOL]);
9667
9668 }
9669 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9670 field_types[i]=sha1_type_;
9671
9672 }else if(shape[0]>=1&&shape[1]<1){
9673 dbtypes[i]=MAP_VL_STRING_BOOL;
9674 hid_t item_type0;
9675 hsize_t shape01=shape[0];
9676 hid_t item_type1key;
9677 item_type1key=sha1_type_;
9678 hid_t item_type1val;
9679 item_type1val=H5T_NATIVE_CHAR;
9680 hid_t item_type1compound;
9681 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9682 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9683 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9684 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9685 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(char))*shape[0]);
9686 field_types[i]=item_type0;
9687 opened_types_.insert(item_type1compound);
9688 opened_types_.insert(field_types[i]);
9689
9690 }else{
9691 dbtypes[i]=MAP_STRING_BOOL;
9692 hid_t item_type0;
9693 hsize_t shape01=shape[0];
9694 hid_t item_type1key;
9695 item_type1key=CreateFLStrType(shape[1]);
9696 hid_t item_type1val;
9697 item_type1val=H5T_NATIVE_CHAR;
9698 hid_t item_type1compound;
9699 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(char));
9700 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9701 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9702 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9703 dst_sizes[i]=((shape[1]+sizeof(char))*shape[0]);
9704 field_types[i]=item_type0;
9705 opened_types_.insert(item_type1compound);
9706 opened_types_.insert(field_types[i]);
9707
9708 }
9709
9710 }else if(valtype==typeid(std::map<std::string, int>)){
9711 shape=shapes[i];
9712 if(shape.empty()||shape[0]<1&&shape[1]<1){
9713 dbtypes[i]=VL_MAP_VL_STRING_INT;
9714 hid_t item_type0;
9715 hid_t item_type1key;
9716 item_type1key=sha1_type_;
9717 hid_t item_type1val;
9718 item_type1val=H5T_NATIVE_INT;
9719 hid_t item_type1compound;
9720 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9721 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9722 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9723 item_type0=sha1_type_;
9724 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
9725 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
9726 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
9727
9728 }
9729 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9730 field_types[i]=sha1_type_;
9731
9732 }else if(shape[0]<1&&shape[1]>=1){
9733 dbtypes[i]=VL_MAP_STRING_INT;
9734 hid_t item_type0;
9735 hid_t item_type1key;
9736 item_type1key=sha1_type_;
9737 hid_t item_type1val;
9738 item_type1val=H5T_NATIVE_INT;
9739 hid_t item_type1compound;
9740 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9741 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9742 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9743 item_type0=sha1_type_;
9744 if(vldts_.count(VL_MAP_STRING_INT)==0){
9745 vldts_[VL_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
9746 opened_types_.insert(vldts_[VL_MAP_STRING_INT]);
9747
9748 }
9749 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9750 field_types[i]=sha1_type_;
9751
9752 }else if(shape[0]>=1&&shape[1]<1){
9753 dbtypes[i]=MAP_VL_STRING_INT;
9754 hid_t item_type0;
9755 hsize_t shape01=shape[0];
9756 hid_t item_type1key;
9757 item_type1key=sha1_type_;
9758 hid_t item_type1val;
9759 item_type1val=H5T_NATIVE_INT;
9760 hid_t item_type1compound;
9761 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9762 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9763 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9764 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9765 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[0]);
9766 field_types[i]=item_type0;
9767 opened_types_.insert(item_type1compound);
9768 opened_types_.insert(field_types[i]);
9769
9770 }else{
9771 dbtypes[i]=MAP_STRING_INT;
9772 hid_t item_type0;
9773 hsize_t shape01=shape[0];
9774 hid_t item_type1key;
9775 item_type1key=CreateFLStrType(shape[1]);
9776 hid_t item_type1val;
9777 item_type1val=H5T_NATIVE_INT;
9778 hid_t item_type1compound;
9779 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(int));
9780 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9781 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9782 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9783 dst_sizes[i]=((shape[1]+sizeof(int))*shape[0]);
9784 field_types[i]=item_type0;
9785 opened_types_.insert(item_type1compound);
9786 opened_types_.insert(field_types[i]);
9787
9788 }
9789
9790 }else if(valtype==typeid(std::map<std::string, float>)){
9791 shape=shapes[i];
9792 if(shape.empty()||shape[0]<1&&shape[1]<1){
9793 dbtypes[i]=VL_MAP_VL_STRING_FLOAT;
9794 hid_t item_type0;
9795 hid_t item_type1key;
9796 item_type1key=sha1_type_;
9797 hid_t item_type1val;
9798 item_type1val=H5T_NATIVE_FLOAT;
9799 hid_t item_type1compound;
9800 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9801 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9802 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9803 item_type0=sha1_type_;
9804 if(vldts_.count(VL_MAP_VL_STRING_FLOAT)==0){
9805 vldts_[VL_MAP_VL_STRING_FLOAT]=H5Tvlen_create(item_type1compound);
9806 opened_types_.insert(vldts_[VL_MAP_VL_STRING_FLOAT]);
9807
9808 }
9809 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9810 field_types[i]=sha1_type_;
9811
9812 }else if(shape[0]<1&&shape[1]>=1){
9813 dbtypes[i]=VL_MAP_STRING_FLOAT;
9814 hid_t item_type0;
9815 hid_t item_type1key;
9816 item_type1key=sha1_type_;
9817 hid_t item_type1val;
9818 item_type1val=H5T_NATIVE_FLOAT;
9819 hid_t item_type1compound;
9820 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9821 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9822 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9823 item_type0=sha1_type_;
9824 if(vldts_.count(VL_MAP_STRING_FLOAT)==0){
9825 vldts_[VL_MAP_STRING_FLOAT]=H5Tvlen_create(item_type1compound);
9826 opened_types_.insert(vldts_[VL_MAP_STRING_FLOAT]);
9827
9828 }
9829 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9830 field_types[i]=sha1_type_;
9831
9832 }else if(shape[0]>=1&&shape[1]<1){
9833 dbtypes[i]=MAP_VL_STRING_FLOAT;
9834 hid_t item_type0;
9835 hsize_t shape01=shape[0];
9836 hid_t item_type1key;
9837 item_type1key=sha1_type_;
9838 hid_t item_type1val;
9839 item_type1val=H5T_NATIVE_FLOAT;
9840 hid_t item_type1compound;
9841 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9842 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9843 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9844 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9845 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(float))*shape[0]);
9846 field_types[i]=item_type0;
9847 opened_types_.insert(item_type1compound);
9848 opened_types_.insert(field_types[i]);
9849
9850 }else{
9851 dbtypes[i]=MAP_STRING_FLOAT;
9852 hid_t item_type0;
9853 hsize_t shape01=shape[0];
9854 hid_t item_type1key;
9855 item_type1key=CreateFLStrType(shape[1]);
9856 hid_t item_type1val;
9857 item_type1val=H5T_NATIVE_FLOAT;
9858 hid_t item_type1compound;
9859 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(float));
9860 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9861 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9862 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9863 dst_sizes[i]=((shape[1]+sizeof(float))*shape[0]);
9864 field_types[i]=item_type0;
9865 opened_types_.insert(item_type1compound);
9866 opened_types_.insert(field_types[i]);
9867
9868 }
9869
9870 }else if(valtype==typeid(std::map<std::string, double>)){
9871 shape=shapes[i];
9872 if(shape.empty()||shape[0]<1&&shape[1]<1){
9873 dbtypes[i]=VL_MAP_VL_STRING_DOUBLE;
9874 hid_t item_type0;
9875 hid_t item_type1key;
9876 item_type1key=sha1_type_;
9877 hid_t item_type1val;
9878 item_type1val=H5T_NATIVE_DOUBLE;
9879 hid_t item_type1compound;
9880 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9881 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9882 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9883 item_type0=sha1_type_;
9884 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
9885 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
9886 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
9887
9888 }
9889 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9890 field_types[i]=sha1_type_;
9891
9892 }else if(shape[0]<1&&shape[1]>=1){
9893 dbtypes[i]=VL_MAP_STRING_DOUBLE;
9894 hid_t item_type0;
9895 hid_t item_type1key;
9896 item_type1key=sha1_type_;
9897 hid_t item_type1val;
9898 item_type1val=H5T_NATIVE_DOUBLE;
9899 hid_t item_type1compound;
9900 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9901 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9902 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9903 item_type0=sha1_type_;
9904 if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
9905 vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
9906 opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
9907
9908 }
9909 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9910 field_types[i]=sha1_type_;
9911
9912 }else if(shape[0]>=1&&shape[1]<1){
9913 dbtypes[i]=MAP_VL_STRING_DOUBLE;
9914 hid_t item_type0;
9915 hsize_t shape01=shape[0];
9916 hid_t item_type1key;
9917 item_type1key=sha1_type_;
9918 hid_t item_type1val;
9919 item_type1val=H5T_NATIVE_DOUBLE;
9920 hid_t item_type1compound;
9921 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9922 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9923 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9924 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9925 dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[0]);
9926 field_types[i]=item_type0;
9927 opened_types_.insert(item_type1compound);
9928 opened_types_.insert(field_types[i]);
9929
9930 }else{
9931 dbtypes[i]=MAP_STRING_DOUBLE;
9932 hid_t item_type0;
9933 hsize_t shape01=shape[0];
9934 hid_t item_type1key;
9935 item_type1key=CreateFLStrType(shape[1]);
9936 hid_t item_type1val;
9937 item_type1val=H5T_NATIVE_DOUBLE;
9938 hid_t item_type1compound;
9939 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(double));
9940 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9941 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9942 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9943 dst_sizes[i]=((shape[1]+sizeof(double))*shape[0]);
9944 field_types[i]=item_type0;
9945 opened_types_.insert(item_type1compound);
9946 opened_types_.insert(field_types[i]);
9947
9948 }
9949
9950 }else if(valtype==typeid(std::map<std::string, std::string>)){
9951 shape=shapes[i];
9952 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
9953 dbtypes[i]=VL_MAP_VL_STRING_VL_STRING;
9954 hid_t item_type0;
9955 hid_t item_type1key;
9956 item_type1key=sha1_type_;
9957 hid_t item_type1val;
9958 item_type1val=sha1_type_;
9959 hid_t item_type1compound;
9960 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9961 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9962 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9963 item_type0=sha1_type_;
9964 if(vldts_.count(VL_MAP_VL_STRING_VL_STRING)==0){
9965 vldts_[VL_MAP_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
9966 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_STRING]);
9967
9968 }
9969 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9970 field_types[i]=sha1_type_;
9971
9972 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1){
9973 dbtypes[i]=VL_MAP_STRING_STRING;
9974 hid_t item_type0;
9975 hid_t item_type1key;
9976 item_type1key=sha1_type_;
9977 hid_t item_type1val;
9978 item_type1val=sha1_type_;
9979 hid_t item_type1compound;
9980 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9981 H5Tinsert(item_type1compound, "key", 0, item_type1key);
9982 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9983 item_type0=sha1_type_;
9984 if(vldts_.count(VL_MAP_STRING_STRING)==0){
9985 vldts_[VL_MAP_STRING_STRING]=H5Tvlen_create(item_type1compound);
9986 opened_types_.insert(vldts_[VL_MAP_STRING_STRING]);
9987
9988 }
9989 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9990 field_types[i]=sha1_type_;
9991
9992 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1){
9993 dbtypes[i]=MAP_STRING_VL_STRING;
9994 hid_t item_type0;
9995 hsize_t shape01=shape[0];
9996 hid_t item_type1key;
9997 item_type1key=CreateFLStrType(shape[1]);
9998 hid_t item_type1val;
9999 item_type1val=sha1_type_;
10000 hid_t item_type1compound;
10001 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
10002 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10003 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10004 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10005 dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
10006 field_types[i]=item_type0;
10007 opened_types_.insert(item_type1compound);
10008 opened_types_.insert(field_types[i]);
10009
10010 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10011 dbtypes[i]=VL_MAP_STRING_VL_STRING;
10012 hid_t item_type0;
10013 hid_t item_type1key;
10014 item_type1key=sha1_type_;
10015 hid_t item_type1val;
10016 item_type1val=sha1_type_;
10017 hid_t item_type1compound;
10018 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10019 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10020 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10021 item_type0=sha1_type_;
10022 if(vldts_.count(VL_MAP_STRING_VL_STRING)==0){
10023 vldts_[VL_MAP_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
10024 opened_types_.insert(vldts_[VL_MAP_STRING_VL_STRING]);
10025
10026 }
10027 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10028 field_types[i]=sha1_type_;
10029
10030 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1){
10031 dbtypes[i]=MAP_VL_STRING_STRING;
10032 hid_t item_type0;
10033 hsize_t shape01=shape[0];
10034 hid_t item_type1key;
10035 item_type1key=sha1_type_;
10036 hid_t item_type1val;
10037 item_type1val=CreateFLStrType(shape[2]);
10038 hid_t item_type1compound;
10039 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[2]);
10040 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10041 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10042 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10043 dst_sizes[i]=((CYCLUS_SHA1_SIZE+shape[2])*shape[0]);
10044 field_types[i]=item_type0;
10045 opened_types_.insert(item_type1compound);
10046 opened_types_.insert(field_types[i]);
10047
10048 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1){
10049 dbtypes[i]=VL_MAP_VL_STRING_STRING;
10050 hid_t item_type0;
10051 hid_t item_type1key;
10052 item_type1key=sha1_type_;
10053 hid_t item_type1val;
10054 item_type1val=sha1_type_;
10055 hid_t item_type1compound;
10056 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10057 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10058 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10059 item_type0=sha1_type_;
10060 if(vldts_.count(VL_MAP_VL_STRING_STRING)==0){
10061 vldts_[VL_MAP_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
10062 opened_types_.insert(vldts_[VL_MAP_VL_STRING_STRING]);
10063
10064 }
10065 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10066 field_types[i]=sha1_type_;
10067
10068 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10069 dbtypes[i]=MAP_VL_STRING_VL_STRING;
10070 hid_t item_type0;
10071 hsize_t shape01=shape[0];
10072 hid_t item_type1key;
10073 item_type1key=sha1_type_;
10074 hid_t item_type1val;
10075 item_type1val=sha1_type_;
10076 hid_t item_type1compound;
10077 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10078 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10079 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10080 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10081 dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
10082 field_types[i]=item_type0;
10083 opened_types_.insert(item_type1compound);
10084 opened_types_.insert(field_types[i]);
10085
10086 }else{
10087 dbtypes[i]=MAP_STRING_STRING;
10088 hid_t item_type0;
10089 hsize_t shape01=shape[0];
10090 hid_t item_type1key;
10091 item_type1key=CreateFLStrType(shape[1]);
10092 hid_t item_type1val;
10093 item_type1val=CreateFLStrType(shape[2]);
10094 hid_t item_type1compound;
10095 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+shape[2]);
10096 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10097 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10098 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10099 dst_sizes[i]=((shape[1]+shape[2])*shape[0]);
10100 field_types[i]=item_type0;
10101 opened_types_.insert(item_type1compound);
10102 opened_types_.insert(field_types[i]);
10103
10104 }
10105
10106 }else if(valtype==typeid(std::map<std::string, cyclus::Blob>)){
10107 shape=shapes[i];
10108 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
10109 dbtypes[i]=VL_MAP_VL_STRING_BLOB;
10110 hid_t item_type0;
10111 hid_t item_type1key;
10112 item_type1key=sha1_type_;
10113 hid_t item_type1val;
10114 item_type1val=sha1_type_;
10115 hid_t item_type1compound;
10116 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10117 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10118 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10119 item_type0=sha1_type_;
10120 if(vldts_.count(VL_MAP_VL_STRING_BLOB)==0){
10121 vldts_[VL_MAP_VL_STRING_BLOB]=H5Tvlen_create(item_type1compound);
10122 opened_types_.insert(vldts_[VL_MAP_VL_STRING_BLOB]);
10123
10124 }
10125 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10126 field_types[i]=sha1_type_;
10127
10128 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10129 dbtypes[i]=VL_MAP_STRING_BLOB;
10130 hid_t item_type0;
10131 hid_t item_type1key;
10132 item_type1key=sha1_type_;
10133 hid_t item_type1val;
10134 item_type1val=sha1_type_;
10135 hid_t item_type1compound;
10136 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10137 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10138 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10139 item_type0=sha1_type_;
10140 if(vldts_.count(VL_MAP_STRING_BLOB)==0){
10141 vldts_[VL_MAP_STRING_BLOB]=H5Tvlen_create(item_type1compound);
10142 opened_types_.insert(vldts_[VL_MAP_STRING_BLOB]);
10143
10144 }
10145 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10146 field_types[i]=sha1_type_;
10147
10148 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10149 dbtypes[i]=MAP_VL_STRING_BLOB;
10150 hid_t item_type0;
10151 hsize_t shape01=shape[0];
10152 hid_t item_type1key;
10153 item_type1key=sha1_type_;
10154 hid_t item_type1val;
10155 item_type1val=sha1_type_;
10156 hid_t item_type1compound;
10157 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10158 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10159 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10160 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10161 dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
10162 field_types[i]=item_type0;
10163 opened_types_.insert(item_type1compound);
10164 opened_types_.insert(field_types[i]);
10165
10166 }else{
10167 dbtypes[i]=MAP_STRING_BLOB;
10168 hid_t item_type0;
10169 hsize_t shape01=shape[0];
10170 hid_t item_type1key;
10171 item_type1key=CreateFLStrType(shape[1]);
10172 hid_t item_type1val;
10173 item_type1val=sha1_type_;
10174 hid_t item_type1compound;
10175 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
10176 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10177 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10178 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10179 dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
10180 field_types[i]=item_type0;
10181 opened_types_.insert(item_type1compound);
10182 opened_types_.insert(field_types[i]);
10183
10184 }
10185
10186 }else if(valtype==typeid(std::map<std::string, boost::uuids::uuid>)){
10187 shape=shapes[i];
10188 if(shape.empty()||shape[0]<1&&shape[1]<1){
10189 dbtypes[i]=VL_MAP_VL_STRING_UUID;
10190 hid_t item_type0;
10191 hid_t item_type1key;
10192 item_type1key=sha1_type_;
10193 hid_t item_type1val;
10194 item_type1val=uuid_type_;
10195 hid_t item_type1compound;
10196 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
10197 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10198 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10199 item_type0=sha1_type_;
10200 if(vldts_.count(VL_MAP_VL_STRING_UUID)==0){
10201 vldts_[VL_MAP_VL_STRING_UUID]=H5Tvlen_create(item_type1compound);
10202 opened_types_.insert(vldts_[VL_MAP_VL_STRING_UUID]);
10203
10204 }
10205 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10206 field_types[i]=sha1_type_;
10207
10208 }else if(shape[0]<1&&shape[1]>=1){
10209 dbtypes[i]=VL_MAP_STRING_UUID;
10210 hid_t item_type0;
10211 hid_t item_type1key;
10212 item_type1key=sha1_type_;
10213 hid_t item_type1val;
10214 item_type1val=uuid_type_;
10215 hid_t item_type1compound;
10216 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
10217 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10218 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10219 item_type0=sha1_type_;
10220 if(vldts_.count(VL_MAP_STRING_UUID)==0){
10221 vldts_[VL_MAP_STRING_UUID]=H5Tvlen_create(item_type1compound);
10222 opened_types_.insert(vldts_[VL_MAP_STRING_UUID]);
10223
10224 }
10225 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10226 field_types[i]=sha1_type_;
10227
10228 }else if(shape[0]>=1&&shape[1]<1){
10229 dbtypes[i]=MAP_VL_STRING_UUID;
10230 hid_t item_type0;
10231 hsize_t shape01=shape[0];
10232 hid_t item_type1key;
10233 item_type1key=sha1_type_;
10234 hid_t item_type1val;
10235 item_type1val=uuid_type_;
10236 hid_t item_type1compound;
10237 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
10238 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10239 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10240 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10241 dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE)*shape[0]);
10242 field_types[i]=item_type0;
10243 opened_types_.insert(item_type1compound);
10244 opened_types_.insert(field_types[i]);
10245
10246 }else{
10247 dbtypes[i]=MAP_STRING_UUID;
10248 hid_t item_type0;
10249 hsize_t shape01=shape[0];
10250 hid_t item_type1key;
10251 item_type1key=CreateFLStrType(shape[1]);
10252 hid_t item_type1val;
10253 item_type1val=uuid_type_;
10254 hid_t item_type1compound;
10255 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_UUID_SIZE);
10256 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10257 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10258 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10259 dst_sizes[i]=((shape[1]+CYCLUS_UUID_SIZE)*shape[0]);
10260 field_types[i]=item_type0;
10261 opened_types_.insert(item_type1compound);
10262 opened_types_.insert(field_types[i]);
10263
10264 }
10265
10266 }else if(valtype==typeid(std::map<std::pair<int, std::string>, double>)){
10267 shape=shapes[i];
10268 if(shape.empty()||shape[0]<1&&shape[3]<1){
10269 dbtypes[i]=VL_MAP_PAIR_INT_VL_STRING_DOUBLE;
10270 hid_t item_type0;
10271 hid_t item_type1key;
10272 hid_t item_type2first;
10273 item_type2first=H5T_NATIVE_INT;
10274 hid_t item_type2second;
10275 item_type2second=sha1_type_;
10276 hid_t item_type2keycompound;
10277 item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
10278 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10279 H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10280 hid_t item_type1val;
10281 item_type1val=H5T_NATIVE_DOUBLE;
10282 hid_t item_type1compound;
10283 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double));
10284 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10285 H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+CYCLUS_SHA1_SIZE)), item_type1val);
10286 item_type0=sha1_type_;
10287 if(vldts_.count(VL_MAP_PAIR_INT_VL_STRING_DOUBLE)==0){
10288 vldts_[VL_MAP_PAIR_INT_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
10289 opened_types_.insert(vldts_[VL_MAP_PAIR_INT_VL_STRING_DOUBLE]);
10290
10291 }
10292 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10293 field_types[i]=sha1_type_;
10294
10295 }else if(shape[0]<1&&shape[3]>=1){
10296 dbtypes[i]=VL_MAP_PAIR_INT_STRING_DOUBLE;
10297 hid_t item_type0;
10298 hid_t item_type1key;
10299 hid_t item_type2first;
10300 item_type2first=H5T_NATIVE_INT;
10301 hid_t item_type2second;
10302 item_type2second=sha1_type_;
10303 hid_t item_type2keycompound;
10304 item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
10305 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10306 H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10307 hid_t item_type1val;
10308 item_type1val=H5T_NATIVE_DOUBLE;
10309 hid_t item_type1compound;
10310 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double));
10311 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10312 H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+CYCLUS_SHA1_SIZE)), item_type1val);
10313 item_type0=sha1_type_;
10314 if(vldts_.count(VL_MAP_PAIR_INT_STRING_DOUBLE)==0){
10315 vldts_[VL_MAP_PAIR_INT_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
10316 opened_types_.insert(vldts_[VL_MAP_PAIR_INT_STRING_DOUBLE]);
10317
10318 }
10319 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10320 field_types[i]=sha1_type_;
10321
10322 }else if(shape[0]>=1&&shape[3]<1){
10323 dbtypes[i]=MAP_PAIR_INT_VL_STRING_DOUBLE;
10324 hid_t item_type0;
10325 hsize_t shape01=shape[0];
10326 hid_t item_type1key;
10327 hid_t item_type2first;
10328 item_type2first=H5T_NATIVE_INT;
10329 hid_t item_type2second;
10330 item_type2second=sha1_type_;
10331 hid_t item_type2keycompound;
10332 item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
10333 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10334 H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10335 hid_t item_type1val;
10336 item_type1val=H5T_NATIVE_DOUBLE;
10337 hid_t item_type1compound;
10338 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double));
10339 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10340 H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+CYCLUS_SHA1_SIZE)), item_type1val);
10341 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10342 dst_sizes[i]=((((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double))*shape[0]);
10343 field_types[i]=item_type0;
10344 opened_types_.insert(item_type2keycompound);
10345 opened_types_.insert(item_type1compound);
10346 opened_types_.insert(field_types[i]);
10347
10348 }else{
10349 dbtypes[i]=MAP_PAIR_INT_STRING_DOUBLE;
10350 hid_t item_type0;
10351 hsize_t shape01=shape[0];
10352 hid_t item_type1key;
10353 hid_t item_type2first;
10354 item_type2first=H5T_NATIVE_INT;
10355 hid_t item_type2second;
10356 item_type2second=CreateFLStrType(shape[3]);
10357 hid_t item_type2keycompound;
10358 item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+shape[3]);
10359 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10360 H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10361 hid_t item_type1val;
10362 item_type1val=H5T_NATIVE_DOUBLE;
10363 hid_t item_type1compound;
10364 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+shape[3]))+sizeof(double));
10365 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10366 H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+shape[3])), item_type1val);
10367 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10368 dst_sizes[i]=((((sizeof(int)+shape[3]))+sizeof(double))*shape[0]);
10369 field_types[i]=item_type0;
10370 opened_types_.insert(item_type2keycompound);
10371 opened_types_.insert(item_type1compound);
10372 opened_types_.insert(field_types[i]);
10373
10374 }
10375
10376 }else if(valtype==typeid(std::map<std::string, std::vector<double>>)){
10377 shape=shapes[i];
10378 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
10379 dbtypes[i]=VL_MAP_VL_STRING_VL_VECTOR_DOUBLE;
10380 hid_t item_type0;
10381 hid_t item_type1key;
10382 item_type1key=sha1_type_;
10383 hid_t item_type1val;
10384 hid_t item_type2elem;
10385 item_type2elem=H5T_NATIVE_DOUBLE;
10386 item_type1val=sha1_type_;
10387 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10388 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10389 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10390
10391 }
10392 hid_t item_type1compound;
10393 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10394 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10395 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10396 item_type0=sha1_type_;
10397 if(vldts_.count(VL_MAP_VL_STRING_VL_VECTOR_DOUBLE)==0){
10398 vldts_[VL_MAP_VL_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10399 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_DOUBLE]);
10400
10401 }
10402 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10403 field_types[i]=sha1_type_;
10404
10405 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1){
10406 dbtypes[i]=MAP_STRING_VL_VECTOR_DOUBLE;
10407 hid_t item_type0;
10408 hsize_t shape01=shape[0];
10409 hid_t item_type1key;
10410 item_type1key=CreateFLStrType(shape[1]);
10411 hid_t item_type1val;
10412 hid_t item_type2elem;
10413 item_type2elem=H5T_NATIVE_DOUBLE;
10414 item_type1val=sha1_type_;
10415 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10416 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10417 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10418
10419 }
10420 hid_t item_type1compound;
10421 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
10422 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10423 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10424 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10425 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
10426 field_types[i]=item_type0;
10427 opened_types_.insert(item_type1val);
10428 opened_types_.insert(item_type1compound);
10429 opened_types_.insert(field_types[i]);
10430
10431 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1){
10432 dbtypes[i]=VL_MAP_STRING_VECTOR_DOUBLE;
10433 hid_t item_type0;
10434 hid_t item_type1key;
10435 item_type1key=sha1_type_;
10436 hid_t item_type1val;
10437 hsize_t shape02=shape[2];
10438 hid_t item_type2elem;
10439 item_type2elem=H5T_NATIVE_DOUBLE;
10440 item_type1val=sha1_type_;
10441 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10442 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10443 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10444
10445 }
10446 hid_t item_type1compound;
10447 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10448 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10449 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10450 item_type0=sha1_type_;
10451 if(vldts_.count(VL_MAP_STRING_VECTOR_DOUBLE)==0){
10452 vldts_[VL_MAP_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10453 opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_DOUBLE]);
10454
10455 }
10456 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10457 field_types[i]=sha1_type_;
10458
10459 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1){
10460 dbtypes[i]=MAP_VL_STRING_VECTOR_DOUBLE;
10461 hid_t item_type0;
10462 hsize_t shape01=shape[0];
10463 hid_t item_type1key;
10464 item_type1key=sha1_type_;
10465 hid_t item_type1val;
10466 hsize_t shape02=shape[2];
10467 hid_t item_type2elem;
10468 item_type2elem=H5T_NATIVE_DOUBLE;
10469 item_type1val=H5Tarray_create2(item_type2elem, 1, &shape02);
10470 hid_t item_type1compound;
10471 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]));
10472 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10473 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10474 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10475 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]))*shape[0]);
10476 field_types[i]=item_type0;
10477 opened_types_.insert(item_type1val);
10478 opened_types_.insert(item_type1compound);
10479 opened_types_.insert(field_types[i]);
10480
10481 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10482 dbtypes[i]=MAP_VL_STRING_VL_VECTOR_DOUBLE;
10483 hid_t item_type0;
10484 hsize_t shape01=shape[0];
10485 hid_t item_type1key;
10486 item_type1key=sha1_type_;
10487 hid_t item_type1val;
10488 hid_t item_type2elem;
10489 item_type2elem=H5T_NATIVE_DOUBLE;
10490 item_type1val=sha1_type_;
10491 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10492 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10493 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10494
10495 }
10496 hid_t item_type1compound;
10497 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10498 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10499 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10500 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10501 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
10502 field_types[i]=item_type0;
10503 opened_types_.insert(item_type1val);
10504 opened_types_.insert(item_type1compound);
10505 opened_types_.insert(field_types[i]);
10506
10507 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10508 dbtypes[i]=VL_MAP_STRING_VL_VECTOR_DOUBLE;
10509 hid_t item_type0;
10510 hid_t item_type1key;
10511 item_type1key=sha1_type_;
10512 hid_t item_type1val;
10513 hid_t item_type2elem;
10514 item_type2elem=H5T_NATIVE_DOUBLE;
10515 item_type1val=sha1_type_;
10516 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10517 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10518 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10519
10520 }
10521 hid_t item_type1compound;
10522 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10523 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10524 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10525 item_type0=sha1_type_;
10526 if(vldts_.count(VL_MAP_STRING_VL_VECTOR_DOUBLE)==0){
10527 vldts_[VL_MAP_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10528 opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_DOUBLE]);
10529
10530 }
10531 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10532 field_types[i]=sha1_type_;
10533
10534 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1){
10535 dbtypes[i]=VL_MAP_VL_STRING_VECTOR_DOUBLE;
10536 hid_t item_type0;
10537 hid_t item_type1key;
10538 item_type1key=sha1_type_;
10539 hid_t item_type1val;
10540 hsize_t shape02=shape[2];
10541 hid_t item_type2elem;
10542 item_type2elem=H5T_NATIVE_DOUBLE;
10543 item_type1val=sha1_type_;
10544 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10545 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10546 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10547
10548 }
10549 hid_t item_type1compound;
10550 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10551 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10552 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10553 item_type0=sha1_type_;
10554 if(vldts_.count(VL_MAP_VL_STRING_VECTOR_DOUBLE)==0){
10555 vldts_[VL_MAP_VL_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10556 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_DOUBLE]);
10557
10558 }
10559 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10560 field_types[i]=sha1_type_;
10561
10562 }else{
10563 dbtypes[i]=MAP_STRING_VECTOR_DOUBLE;
10564 hid_t item_type0;
10565 hsize_t shape01=shape[0];
10566 hid_t item_type1key;
10567 item_type1key=CreateFLStrType(shape[1]);
10568 hid_t item_type1val;
10569 hsize_t shape02=shape[2];
10570 hid_t item_type2elem;
10571 item_type2elem=H5T_NATIVE_DOUBLE;
10572 item_type1val=H5Tarray_create2(item_type2elem, 1, &shape02);
10573 hid_t item_type1compound;
10574 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double))*shape[2]));
10575 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10576 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10577 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10578 dst_sizes[i]=((shape[1]+((sizeof(double))*shape[2]))*shape[0]);
10579 field_types[i]=item_type0;
10580 opened_types_.insert(item_type1val);
10581 opened_types_.insert(item_type1compound);
10582 opened_types_.insert(field_types[i]);
10583
10584 }
10585
10586 }else if(valtype==typeid(std::map<std::string, std::map<int, double>>)){
10587 shape=shapes[i];
10588 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
10589 dbtypes[i]=VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE;
10590 hid_t item_type0;
10591 hid_t item_type1key;
10592 item_type1key=sha1_type_;
10593 hid_t item_type1val;
10594 hid_t item_type2key;
10595 item_type2key=H5T_NATIVE_INT;
10596 hid_t item_type2val;
10597 item_type2val=H5T_NATIVE_DOUBLE;
10598 hid_t item_type2valcompound;
10599 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10600 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10601 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10602 item_type1val=sha1_type_;
10603 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10604 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10605 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10606
10607 }
10608 hid_t item_type1compound;
10609 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10610 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10611 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10612 item_type0=sha1_type_;
10613 if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE)==0){
10614 vldts_[VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10615 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE]);
10616
10617 }
10618 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10619 field_types[i]=sha1_type_;
10620
10621 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1){
10622 dbtypes[i]=MAP_STRING_VL_MAP_INT_DOUBLE;
10623 hid_t item_type0;
10624 hsize_t shape01=shape[0];
10625 hid_t item_type1key;
10626 item_type1key=CreateFLStrType(shape[1]);
10627 hid_t item_type1val;
10628 hid_t item_type2key;
10629 item_type2key=H5T_NATIVE_INT;
10630 hid_t item_type2val;
10631 item_type2val=H5T_NATIVE_DOUBLE;
10632 hid_t item_type2valcompound;
10633 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10634 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10635 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10636 item_type1val=sha1_type_;
10637 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10638 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10639 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10640
10641 }
10642 hid_t item_type1compound;
10643 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
10644 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10645 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10646 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10647 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
10648 field_types[i]=item_type0;
10649 opened_types_.insert(item_type2valcompound);
10650 opened_types_.insert(item_type1val);
10651 opened_types_.insert(item_type1compound);
10652 opened_types_.insert(field_types[i]);
10653
10654 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1){
10655 dbtypes[i]=VL_MAP_STRING_MAP_INT_DOUBLE;
10656 hid_t item_type0;
10657 hid_t item_type1key;
10658 item_type1key=sha1_type_;
10659 hid_t item_type1val;
10660 hsize_t shape02=shape[2];
10661 hid_t item_type2key;
10662 item_type2key=H5T_NATIVE_INT;
10663 hid_t item_type2val;
10664 item_type2val=H5T_NATIVE_DOUBLE;
10665 hid_t item_type2valcompound;
10666 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10667 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10668 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10669 item_type1val=sha1_type_;
10670 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10671 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10672 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10673
10674 }
10675 hid_t item_type1compound;
10676 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10677 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10678 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10679 item_type0=sha1_type_;
10680 if(vldts_.count(VL_MAP_STRING_MAP_INT_DOUBLE)==0){
10681 vldts_[VL_MAP_STRING_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10682 opened_types_.insert(vldts_[VL_MAP_STRING_MAP_INT_DOUBLE]);
10683
10684 }
10685 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10686 field_types[i]=sha1_type_;
10687
10688 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1){
10689 dbtypes[i]=MAP_VL_STRING_MAP_INT_DOUBLE;
10690 hid_t item_type0;
10691 hsize_t shape01=shape[0];
10692 hid_t item_type1key;
10693 item_type1key=sha1_type_;
10694 hid_t item_type1val;
10695 hsize_t shape02=shape[2];
10696 hid_t item_type2key;
10697 item_type2key=H5T_NATIVE_INT;
10698 hid_t item_type2val;
10699 item_type2val=H5T_NATIVE_DOUBLE;
10700 hid_t item_type2valcompound;
10701 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10702 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10703 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10704 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
10705 hid_t item_type1compound;
10706 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(int)+sizeof(double))*shape[2]));
10707 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10708 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10709 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10710 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
10711 field_types[i]=item_type0;
10712 opened_types_.insert(item_type2valcompound);
10713 opened_types_.insert(item_type1val);
10714 opened_types_.insert(item_type1compound);
10715 opened_types_.insert(field_types[i]);
10716
10717 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10718 dbtypes[i]=MAP_VL_STRING_VL_MAP_INT_DOUBLE;
10719 hid_t item_type0;
10720 hsize_t shape01=shape[0];
10721 hid_t item_type1key;
10722 item_type1key=sha1_type_;
10723 hid_t item_type1val;
10724 hid_t item_type2key;
10725 item_type2key=H5T_NATIVE_INT;
10726 hid_t item_type2val;
10727 item_type2val=H5T_NATIVE_DOUBLE;
10728 hid_t item_type2valcompound;
10729 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10730 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10731 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10732 item_type1val=sha1_type_;
10733 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10734 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10735 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10736
10737 }
10738 hid_t item_type1compound;
10739 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10740 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10741 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10742 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10743 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
10744 field_types[i]=item_type0;
10745 opened_types_.insert(item_type2valcompound);
10746 opened_types_.insert(item_type1val);
10747 opened_types_.insert(item_type1compound);
10748 opened_types_.insert(field_types[i]);
10749
10750 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10751 dbtypes[i]=VL_MAP_STRING_VL_MAP_INT_DOUBLE;
10752 hid_t item_type0;
10753 hid_t item_type1key;
10754 item_type1key=sha1_type_;
10755 hid_t item_type1val;
10756 hid_t item_type2key;
10757 item_type2key=H5T_NATIVE_INT;
10758 hid_t item_type2val;
10759 item_type2val=H5T_NATIVE_DOUBLE;
10760 hid_t item_type2valcompound;
10761 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10762 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10763 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10764 item_type1val=sha1_type_;
10765 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10766 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10767 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10768
10769 }
10770 hid_t item_type1compound;
10771 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10772 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10773 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10774 item_type0=sha1_type_;
10775 if(vldts_.count(VL_MAP_STRING_VL_MAP_INT_DOUBLE)==0){
10776 vldts_[VL_MAP_STRING_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10777 opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_INT_DOUBLE]);
10778
10779 }
10780 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10781 field_types[i]=sha1_type_;
10782
10783 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1){
10784 dbtypes[i]=VL_MAP_VL_STRING_MAP_INT_DOUBLE;
10785 hid_t item_type0;
10786 hid_t item_type1key;
10787 item_type1key=sha1_type_;
10788 hid_t item_type1val;
10789 hsize_t shape02=shape[2];
10790 hid_t item_type2key;
10791 item_type2key=H5T_NATIVE_INT;
10792 hid_t item_type2val;
10793 item_type2val=H5T_NATIVE_DOUBLE;
10794 hid_t item_type2valcompound;
10795 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10796 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10797 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10798 item_type1val=sha1_type_;
10799 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10800 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10801 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10802
10803 }
10804 hid_t item_type1compound;
10805 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10806 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10807 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10808 item_type0=sha1_type_;
10809 if(vldts_.count(VL_MAP_VL_STRING_MAP_INT_DOUBLE)==0){
10810 vldts_[VL_MAP_VL_STRING_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10811 opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_INT_DOUBLE]);
10812
10813 }
10814 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10815 field_types[i]=sha1_type_;
10816
10817 }else{
10818 dbtypes[i]=MAP_STRING_MAP_INT_DOUBLE;
10819 hid_t item_type0;
10820 hsize_t shape01=shape[0];
10821 hid_t item_type1key;
10822 item_type1key=CreateFLStrType(shape[1]);
10823 hid_t item_type1val;
10824 hsize_t shape02=shape[2];
10825 hid_t item_type2key;
10826 item_type2key=H5T_NATIVE_INT;
10827 hid_t item_type2val;
10828 item_type2val=H5T_NATIVE_DOUBLE;
10829 hid_t item_type2valcompound;
10830 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10831 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10832 H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10833 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
10834 hid_t item_type1compound;
10835 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(int)+sizeof(double))*shape[2]));
10836 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10837 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10838 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10839 dst_sizes[i]=((shape[1]+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
10840 field_types[i]=item_type0;
10841 opened_types_.insert(item_type2valcompound);
10842 opened_types_.insert(item_type1val);
10843 opened_types_.insert(item_type1compound);
10844 opened_types_.insert(field_types[i]);
10845
10846 }
10847
10848 }else if(valtype==typeid(std::map<std::string, std::pair<double, std::map<int, double>>>)){
10849 shape=shapes[i];
10850 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[4]<1){
10851 dbtypes[i]=VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE;
10852 hid_t item_type0;
10853 hid_t item_type1key;
10854 item_type1key=sha1_type_;
10855 hid_t item_type1val;
10856 hid_t item_type2first;
10857 item_type2first=H5T_NATIVE_DOUBLE;
10858 hid_t item_type2second;
10859 hid_t item_type3key;
10860 item_type3key=H5T_NATIVE_INT;
10861 hid_t item_type3val;
10862 item_type3val=H5T_NATIVE_DOUBLE;
10863 hid_t item_type3secondcompound;
10864 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10865 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10866 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10867 item_type2second=sha1_type_;
10868 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10869 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
10870 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10871
10872 }
10873 hid_t item_type2valcompound;
10874 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
10875 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10876 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10877 hid_t item_type1compound;
10878 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
10879 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10880 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
10881 item_type0=sha1_type_;
10882 if(vldts_.count(VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE)==0){
10883 vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10884 opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]);
10885
10886 }
10887 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10888 field_types[i]=sha1_type_;
10889
10890 }else if(shape[0]<1&&shape[1]>=1&&shape[4]>=1){
10891 dbtypes[i]=VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE;
10892 hid_t item_type0;
10893 hid_t item_type1key;
10894 item_type1key=sha1_type_;
10895 hid_t item_type1val;
10896 hid_t item_type2first;
10897 item_type2first=H5T_NATIVE_DOUBLE;
10898 hid_t item_type2second;
10899 hsize_t shape03=shape[4];
10900 hid_t item_type3key;
10901 item_type3key=H5T_NATIVE_INT;
10902 hid_t item_type3val;
10903 item_type3val=H5T_NATIVE_DOUBLE;
10904 hid_t item_type3secondcompound;
10905 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10906 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10907 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10908 item_type2second=sha1_type_;
10909 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10910 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
10911 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10912
10913 }
10914 hid_t item_type2valcompound;
10915 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
10916 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10917 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10918 hid_t item_type1compound;
10919 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
10920 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10921 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
10922 item_type0=sha1_type_;
10923 if(vldts_.count(VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE)==0){
10924 vldts_[VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10925 opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]);
10926
10927 }
10928 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10929 field_types[i]=sha1_type_;
10930
10931 }else if(shape[0]>=1&&shape[1]<1&&shape[4]>=1){
10932 dbtypes[i]=MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE;
10933 hid_t item_type0;
10934 hsize_t shape01=shape[0];
10935 hid_t item_type1key;
10936 item_type1key=sha1_type_;
10937 hid_t item_type1val;
10938 hid_t item_type2first;
10939 item_type2first=H5T_NATIVE_DOUBLE;
10940 hid_t item_type2second;
10941 hsize_t shape03=shape[4];
10942 hid_t item_type3key;
10943 item_type3key=H5T_NATIVE_INT;
10944 hid_t item_type3val;
10945 item_type3val=H5T_NATIVE_DOUBLE;
10946 hid_t item_type3secondcompound;
10947 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10948 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10949 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10950 item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
10951 hid_t item_type2valcompound;
10952 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]));
10953 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10954 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10955 hid_t item_type1compound;
10956 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))));
10957 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10958 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
10959 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10960 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
10961 field_types[i]=item_type0;
10962 opened_types_.insert(item_type3secondcompound);
10963 opened_types_.insert(item_type2second);
10964 opened_types_.insert(item_type2valcompound);
10965 opened_types_.insert(item_type1compound);
10966 opened_types_.insert(field_types[i]);
10967
10968 }else if(shape[0]>=1&&shape[1]>=1&&shape[4]<1){
10969 dbtypes[i]=MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE;
10970 hid_t item_type0;
10971 hsize_t shape01=shape[0];
10972 hid_t item_type1key;
10973 item_type1key=CreateFLStrType(shape[1]);
10974 hid_t item_type1val;
10975 hid_t item_type2first;
10976 item_type2first=H5T_NATIVE_DOUBLE;
10977 hid_t item_type2second;
10978 hid_t item_type3key;
10979 item_type3key=H5T_NATIVE_INT;
10980 hid_t item_type3val;
10981 item_type3val=H5T_NATIVE_DOUBLE;
10982 hid_t item_type3secondcompound;
10983 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10984 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10985 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10986 item_type2second=sha1_type_;
10987 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10988 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
10989 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10990
10991 }
10992 hid_t item_type2valcompound;
10993 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
10994 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10995 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10996 hid_t item_type1compound;
10997 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
10998 H5Tinsert(item_type1compound, "key", 0, item_type1key);
10999 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
11000 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11001 dst_sizes[i]=((shape[1]+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
11002 field_types[i]=item_type0;
11003 opened_types_.insert(item_type3secondcompound);
11004 opened_types_.insert(item_type2second);
11005 opened_types_.insert(item_type2valcompound);
11006 opened_types_.insert(item_type1compound);
11007 opened_types_.insert(field_types[i]);
11008
11009 }else if(shape[0]<1&&shape[1]<1&&shape[4]>=1){
11010 dbtypes[i]=VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE;
11011 hid_t item_type0;
11012 hid_t item_type1key;
11013 item_type1key=sha1_type_;
11014 hid_t item_type1val;
11015 hid_t item_type2first;
11016 item_type2first=H5T_NATIVE_DOUBLE;
11017 hid_t item_type2second;
11018 hsize_t shape03=shape[4];
11019 hid_t item_type3key;
11020 item_type3key=H5T_NATIVE_INT;
11021 hid_t item_type3val;
11022 item_type3val=H5T_NATIVE_DOUBLE;
11023 hid_t item_type3secondcompound;
11024 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11025 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11026 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11027 item_type2second=sha1_type_;
11028 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
11029 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
11030 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
11031
11032 }
11033 hid_t item_type2valcompound;
11034 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
11035 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11036 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11037 hid_t item_type1compound;
11038 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
11039 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11040 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
11041 item_type0=sha1_type_;
11042 if(vldts_.count(VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE)==0){
11043 vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
11044 opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]);
11045
11046 }
11047 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11048 field_types[i]=sha1_type_;
11049
11050 }else if(shape[0]<1&&shape[1]>=1&&shape[4]<1){
11051 dbtypes[i]=VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE;
11052 hid_t item_type0;
11053 hid_t item_type1key;
11054 item_type1key=sha1_type_;
11055 hid_t item_type1val;
11056 hid_t item_type2first;
11057 item_type2first=H5T_NATIVE_DOUBLE;
11058 hid_t item_type2second;
11059 hid_t item_type3key;
11060 item_type3key=H5T_NATIVE_INT;
11061 hid_t item_type3val;
11062 item_type3val=H5T_NATIVE_DOUBLE;
11063 hid_t item_type3secondcompound;
11064 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11065 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11066 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11067 item_type2second=sha1_type_;
11068 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
11069 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
11070 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
11071
11072 }
11073 hid_t item_type2valcompound;
11074 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
11075 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11076 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11077 hid_t item_type1compound;
11078 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
11079 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11080 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
11081 item_type0=sha1_type_;
11082 if(vldts_.count(VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE)==0){
11083 vldts_[VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
11084 opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]);
11085
11086 }
11087 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11088 field_types[i]=sha1_type_;
11089
11090 }else if(shape[0]>=1&&shape[1]<1&&shape[4]<1){
11091 dbtypes[i]=MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE;
11092 hid_t item_type0;
11093 hsize_t shape01=shape[0];
11094 hid_t item_type1key;
11095 item_type1key=sha1_type_;
11096 hid_t item_type1val;
11097 hid_t item_type2first;
11098 item_type2first=H5T_NATIVE_DOUBLE;
11099 hid_t item_type2second;
11100 hid_t item_type3key;
11101 item_type3key=H5T_NATIVE_INT;
11102 hid_t item_type3val;
11103 item_type3val=H5T_NATIVE_DOUBLE;
11104 hid_t item_type3secondcompound;
11105 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11106 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11107 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11108 item_type2second=sha1_type_;
11109 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
11110 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
11111 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
11112
11113 }
11114 hid_t item_type2valcompound;
11115 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
11116 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11117 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11118 hid_t item_type1compound;
11119 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
11120 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11121 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
11122 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11123 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
11124 field_types[i]=item_type0;
11125 opened_types_.insert(item_type3secondcompound);
11126 opened_types_.insert(item_type2second);
11127 opened_types_.insert(item_type2valcompound);
11128 opened_types_.insert(item_type1compound);
11129 opened_types_.insert(field_types[i]);
11130
11131 }else{
11132 dbtypes[i]=MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE;
11133 hid_t item_type0;
11134 hsize_t shape01=shape[0];
11135 hid_t item_type1key;
11136 item_type1key=CreateFLStrType(shape[1]);
11137 hid_t item_type1val;
11138 hid_t item_type2first;
11139 item_type2first=H5T_NATIVE_DOUBLE;
11140 hid_t item_type2second;
11141 hsize_t shape03=shape[4];
11142 hid_t item_type3key;
11143 item_type3key=H5T_NATIVE_INT;
11144 hid_t item_type3val;
11145 item_type3val=H5T_NATIVE_DOUBLE;
11146 hid_t item_type3secondcompound;
11147 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11148 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11149 H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11150 item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
11151 hid_t item_type2valcompound;
11152 item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]));
11153 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11154 H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11155 hid_t item_type1compound;
11156 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))));
11157 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11158 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
11159 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11160 dst_sizes[i]=((shape[1]+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
11161 field_types[i]=item_type0;
11162 opened_types_.insert(item_type3secondcompound);
11163 opened_types_.insert(item_type2second);
11164 opened_types_.insert(item_type2valcompound);
11165 opened_types_.insert(item_type1compound);
11166 opened_types_.insert(field_types[i]);
11167
11168 }
11169
11170 }else if(valtype==typeid(std::map<int, std::map<std::string, double>>)){
11171 shape=shapes[i];
11172 if(shape.empty()||shape[0]<1&&shape[2]<1&&shape[3]<1){
11173 dbtypes[i]=VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE;
11174 hid_t item_type0;
11175 hid_t item_type1key;
11176 item_type1key=H5T_NATIVE_INT;
11177 hid_t item_type1val;
11178 hid_t item_type2key;
11179 item_type2key=sha1_type_;
11180 hid_t item_type2val;
11181 item_type2val=H5T_NATIVE_DOUBLE;
11182 hid_t item_type2valcompound;
11183 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11184 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11185 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11186 item_type1val=sha1_type_;
11187 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11188 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11189 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11190
11191 }
11192 hid_t item_type1compound;
11193 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11194 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11195 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11196 item_type0=sha1_type_;
11197 if(vldts_.count(VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE)==0){
11198 vldts_[VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11199 opened_types_.insert(vldts_[VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE]);
11200
11201 }
11202 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11203 field_types[i]=sha1_type_;
11204
11205 }else if(shape[0]>=1&&shape[2]>=1&&shape[3]<1){
11206 dbtypes[i]=MAP_INT_MAP_VL_STRING_DOUBLE;
11207 hid_t item_type0;
11208 hsize_t shape01=shape[0];
11209 hid_t item_type1key;
11210 item_type1key=H5T_NATIVE_INT;
11211 hid_t item_type1val;
11212 hsize_t shape02=shape[2];
11213 hid_t item_type2key;
11214 item_type2key=sha1_type_;
11215 hid_t item_type2val;
11216 item_type2val=H5T_NATIVE_DOUBLE;
11217 hid_t item_type2valcompound;
11218 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11219 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11220 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11221 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
11222 hid_t item_type1compound;
11223 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]));
11224 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11225 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11226 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11227 dst_sizes[i]=((sizeof(int)+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
11228 field_types[i]=item_type0;
11229 opened_types_.insert(item_type2valcompound);
11230 opened_types_.insert(item_type1val);
11231 opened_types_.insert(item_type1compound);
11232 opened_types_.insert(field_types[i]);
11233
11234 }else if(shape[0]<1&&shape[2]>=1&&shape[3]>=1){
11235 dbtypes[i]=VL_MAP_INT_MAP_STRING_DOUBLE;
11236 hid_t item_type0;
11237 hid_t item_type1key;
11238 item_type1key=H5T_NATIVE_INT;
11239 hid_t item_type1val;
11240 hsize_t shape02=shape[2];
11241 hid_t item_type2key;
11242 item_type2key=sha1_type_;
11243 hid_t item_type2val;
11244 item_type2val=H5T_NATIVE_DOUBLE;
11245 hid_t item_type2valcompound;
11246 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11247 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11248 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11249 item_type1val=sha1_type_;
11250 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11251 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11252 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11253
11254 }
11255 hid_t item_type1compound;
11256 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11257 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11258 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11259 item_type0=sha1_type_;
11260 if(vldts_.count(VL_MAP_INT_MAP_STRING_DOUBLE)==0){
11261 vldts_[VL_MAP_INT_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11262 opened_types_.insert(vldts_[VL_MAP_INT_MAP_STRING_DOUBLE]);
11263
11264 }
11265 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11266 field_types[i]=sha1_type_;
11267
11268 }else if(shape[0]<1&&shape[2]>=1&&shape[3]<1){
11269 dbtypes[i]=VL_MAP_INT_MAP_VL_STRING_DOUBLE;
11270 hid_t item_type0;
11271 hid_t item_type1key;
11272 item_type1key=H5T_NATIVE_INT;
11273 hid_t item_type1val;
11274 hsize_t shape02=shape[2];
11275 hid_t item_type2key;
11276 item_type2key=sha1_type_;
11277 hid_t item_type2val;
11278 item_type2val=H5T_NATIVE_DOUBLE;
11279 hid_t item_type2valcompound;
11280 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11281 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11282 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11283 item_type1val=sha1_type_;
11284 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11285 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11286 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11287
11288 }
11289 hid_t item_type1compound;
11290 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11291 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11292 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11293 item_type0=sha1_type_;
11294 if(vldts_.count(VL_MAP_INT_MAP_VL_STRING_DOUBLE)==0){
11295 vldts_[VL_MAP_INT_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11296 opened_types_.insert(vldts_[VL_MAP_INT_MAP_VL_STRING_DOUBLE]);
11297
11298 }
11299 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11300 field_types[i]=sha1_type_;
11301
11302 }else if(shape[0]>=1&&shape[2]<1&&shape[3]>=1){
11303 dbtypes[i]=MAP_INT_VL_MAP_STRING_DOUBLE;
11304 hid_t item_type0;
11305 hsize_t shape01=shape[0];
11306 hid_t item_type1key;
11307 item_type1key=H5T_NATIVE_INT;
11308 hid_t item_type1val;
11309 hid_t item_type2key;
11310 item_type2key=sha1_type_;
11311 hid_t item_type2val;
11312 item_type2val=H5T_NATIVE_DOUBLE;
11313 hid_t item_type2valcompound;
11314 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11315 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11316 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11317 item_type1val=sha1_type_;
11318 if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
11319 vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11320 opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
11321
11322 }
11323 hid_t item_type1compound;
11324 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11325 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11326 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11327 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11328 dst_sizes[i]=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
11329 field_types[i]=item_type0;
11330 opened_types_.insert(item_type2valcompound);
11331 opened_types_.insert(item_type1val);
11332 opened_types_.insert(item_type1compound);
11333 opened_types_.insert(field_types[i]);
11334
11335 }else if(shape[0]>=1&&shape[2]<1&&shape[3]<1){
11336 dbtypes[i]=MAP_INT_VL_MAP_VL_STRING_DOUBLE;
11337 hid_t item_type0;
11338 hsize_t shape01=shape[0];
11339 hid_t item_type1key;
11340 item_type1key=H5T_NATIVE_INT;
11341 hid_t item_type1val;
11342 hid_t item_type2key;
11343 item_type2key=sha1_type_;
11344 hid_t item_type2val;
11345 item_type2val=H5T_NATIVE_DOUBLE;
11346 hid_t item_type2valcompound;
11347 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11348 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11349 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11350 item_type1val=sha1_type_;
11351 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11352 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11353 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11354
11355 }
11356 hid_t item_type1compound;
11357 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11358 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11359 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11360 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11361 dst_sizes[i]=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
11362 field_types[i]=item_type0;
11363 opened_types_.insert(item_type2valcompound);
11364 opened_types_.insert(item_type1val);
11365 opened_types_.insert(item_type1compound);
11366 opened_types_.insert(field_types[i]);
11367
11368 }else if(shape[0]<1&&shape[2]<1&&shape[3]>=1){
11369 dbtypes[i]=VL_MAP_INT_VL_MAP_STRING_DOUBLE;
11370 hid_t item_type0;
11371 hid_t item_type1key;
11372 item_type1key=H5T_NATIVE_INT;
11373 hid_t item_type1val;
11374 hid_t item_type2key;
11375 item_type2key=sha1_type_;
11376 hid_t item_type2val;
11377 item_type2val=H5T_NATIVE_DOUBLE;
11378 hid_t item_type2valcompound;
11379 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11380 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11381 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11382 item_type1val=sha1_type_;
11383 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11384 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11385 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11386
11387 }
11388 hid_t item_type1compound;
11389 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11390 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11391 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11392 item_type0=sha1_type_;
11393 if(vldts_.count(VL_MAP_INT_VL_MAP_STRING_DOUBLE)==0){
11394 vldts_[VL_MAP_INT_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11395 opened_types_.insert(vldts_[VL_MAP_INT_VL_MAP_STRING_DOUBLE]);
11396
11397 }
11398 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11399 field_types[i]=sha1_type_;
11400
11401 }else{
11402 dbtypes[i]=MAP_INT_MAP_STRING_DOUBLE;
11403 hid_t item_type0;
11404 hsize_t shape01=shape[0];
11405 hid_t item_type1key;
11406 item_type1key=H5T_NATIVE_INT;
11407 hid_t item_type1val;
11408 hsize_t shape02=shape[2];
11409 hid_t item_type2key;
11410 item_type2key=CreateFLStrType(shape[3]);
11411 hid_t item_type2val;
11412 item_type2val=H5T_NATIVE_DOUBLE;
11413 hid_t item_type2valcompound;
11414 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(double));
11415 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11416 H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
11417 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
11418 hid_t item_type1compound;
11419 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[3]+sizeof(double))*shape[2]));
11420 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11421 H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11422 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11423 dst_sizes[i]=((sizeof(int)+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
11424 field_types[i]=item_type0;
11425 opened_types_.insert(item_type2valcompound);
11426 opened_types_.insert(item_type1val);
11427 opened_types_.insert(item_type1compound);
11428 opened_types_.insert(field_types[i]);
11429
11430 }
11431
11432 }else if(valtype==typeid(std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>)){
11433 shape=shapes[i];
11434 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
11435 dbtypes[i]=VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
11436 hid_t item_type0;
11437 hid_t item_type1key;
11438 item_type1key=sha1_type_;
11439 hid_t item_type1val;
11440 hid_t item_type2elem;
11441 hid_t item_type3first;
11442 item_type3first=H5T_NATIVE_INT;
11443 hid_t item_type3second;
11444 hid_t item_type4first;
11445 item_type4first=sha1_type_;
11446 hid_t item_type4second;
11447 item_type4second=sha1_type_;
11448 hid_t item_type4secondcompound;
11449 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11450 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11451 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11452 hid_t item_type3elemcompound;
11453 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11454 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11455 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11456 item_type1val=sha1_type_;
11457 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
11458 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11459 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
11460
11461 }
11462 hid_t item_type1compound;
11463 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
11464 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11465 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11466 item_type0=sha1_type_;
11467 if(vldts_.count(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
11468 vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
11469 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
11470
11471 }
11472 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11473 field_types[i]=sha1_type_;
11474
11475 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
11476 dbtypes[i]=MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
11477 hid_t item_type0;
11478 hsize_t shape01=shape[0];
11479 hid_t item_type1key;
11480 item_type1key=CreateFLStrType(shape[1]);
11481 hid_t item_type1val;
11482 hsize_t shape02=shape[2];
11483 hid_t item_type2elem;
11484 hid_t item_type3first;
11485 item_type3first=H5T_NATIVE_INT;
11486 hid_t item_type3second;
11487 hid_t item_type4first;
11488 item_type4first=CreateFLStrType(shape[6]);
11489 hid_t item_type4second;
11490 item_type4second=sha1_type_;
11491 hid_t item_type4secondcompound;
11492 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+CYCLUS_SHA1_SIZE);
11493 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11494 H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
11495 hid_t item_type3elemcompound;
11496 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)));
11497 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11498 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11499 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11500 hid_t item_type1compound;
11501 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]));
11502 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11503 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11504 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11505 dst_sizes[i]=((shape[1]+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11506 field_types[i]=item_type0;
11507 opened_types_.insert(item_type4secondcompound);
11508 opened_types_.insert(item_type3elemcompound);
11509 opened_types_.insert(item_type1val);
11510 opened_types_.insert(item_type1compound);
11511 opened_types_.insert(field_types[i]);
11512
11513 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
11514 dbtypes[i]=MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
11515 hid_t item_type0;
11516 hsize_t shape01=shape[0];
11517 hid_t item_type1key;
11518 item_type1key=CreateFLStrType(shape[1]);
11519 hid_t item_type1val;
11520 hsize_t shape02=shape[2];
11521 hid_t item_type2elem;
11522 hid_t item_type3first;
11523 item_type3first=H5T_NATIVE_INT;
11524 hid_t item_type3second;
11525 hid_t item_type4first;
11526 item_type4first=sha1_type_;
11527 hid_t item_type4second;
11528 item_type4second=CreateFLStrType(shape[7]);
11529 hid_t item_type4secondcompound;
11530 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[7]);
11531 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11532 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11533 hid_t item_type3elemcompound;
11534 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])));
11535 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11536 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11537 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11538 hid_t item_type1compound;
11539 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]));
11540 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11541 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11542 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11543 dst_sizes[i]=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
11544 field_types[i]=item_type0;
11545 opened_types_.insert(item_type4secondcompound);
11546 opened_types_.insert(item_type3elemcompound);
11547 opened_types_.insert(item_type1val);
11548 opened_types_.insert(item_type1compound);
11549 opened_types_.insert(field_types[i]);
11550
11551 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
11552 dbtypes[i]=MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
11553 hid_t item_type0;
11554 hsize_t shape01=shape[0];
11555 hid_t item_type1key;
11556 item_type1key=CreateFLStrType(shape[1]);
11557 hid_t item_type1val;
11558 hsize_t shape02=shape[2];
11559 hid_t item_type2elem;
11560 hid_t item_type3first;
11561 item_type3first=H5T_NATIVE_INT;
11562 hid_t item_type3second;
11563 hid_t item_type4first;
11564 item_type4first=sha1_type_;
11565 hid_t item_type4second;
11566 item_type4second=sha1_type_;
11567 hid_t item_type4secondcompound;
11568 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11569 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11570 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11571 hid_t item_type3elemcompound;
11572 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11573 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11574 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11575 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11576 hid_t item_type1compound;
11577 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]));
11578 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11579 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11580 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11581 dst_sizes[i]=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11582 field_types[i]=item_type0;
11583 opened_types_.insert(item_type4secondcompound);
11584 opened_types_.insert(item_type3elemcompound);
11585 opened_types_.insert(item_type1val);
11586 opened_types_.insert(item_type1compound);
11587 opened_types_.insert(field_types[i]);
11588
11589 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
11590 dbtypes[i]=MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING;
11591 hid_t item_type0;
11592 hsize_t shape01=shape[0];
11593 hid_t item_type1key;
11594 item_type1key=CreateFLStrType(shape[1]);
11595 hid_t item_type1val;
11596 hid_t item_type2elem;
11597 hid_t item_type3first;
11598 item_type3first=H5T_NATIVE_INT;
11599 hid_t item_type3second;
11600 hid_t item_type4first;
11601 item_type4first=sha1_type_;
11602 hid_t item_type4second;
11603 item_type4second=sha1_type_;
11604 hid_t item_type4secondcompound;
11605 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11606 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11607 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11608 hid_t item_type3elemcompound;
11609 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11610 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11611 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11612 item_type1val=sha1_type_;
11613 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
11614 vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
11615 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
11616
11617 }
11618 hid_t item_type1compound;
11619 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11620 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11621 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11622 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11623 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11624 field_types[i]=item_type0;
11625 opened_types_.insert(item_type4secondcompound);
11626 opened_types_.insert(item_type3elemcompound);
11627 opened_types_.insert(item_type1val);
11628 opened_types_.insert(item_type1compound);
11629 opened_types_.insert(field_types[i]);
11630
11631 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
11632 dbtypes[i]=MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
11633 hid_t item_type0;
11634 hsize_t shape01=shape[0];
11635 hid_t item_type1key;
11636 item_type1key=CreateFLStrType(shape[1]);
11637 hid_t item_type1val;
11638 hid_t item_type2elem;
11639 hid_t item_type3first;
11640 item_type3first=H5T_NATIVE_INT;
11641 hid_t item_type3second;
11642 hid_t item_type4first;
11643 item_type4first=sha1_type_;
11644 hid_t item_type4second;
11645 item_type4second=sha1_type_;
11646 hid_t item_type4secondcompound;
11647 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11648 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11649 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11650 hid_t item_type3elemcompound;
11651 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11652 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11653 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11654 item_type1val=sha1_type_;
11655 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
11656 vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11657 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
11658
11659 }
11660 hid_t item_type1compound;
11661 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11662 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11663 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11664 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11665 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11666 field_types[i]=item_type0;
11667 opened_types_.insert(item_type4secondcompound);
11668 opened_types_.insert(item_type3elemcompound);
11669 opened_types_.insert(item_type1val);
11670 opened_types_.insert(item_type1compound);
11671 opened_types_.insert(field_types[i]);
11672
11673 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
11674 dbtypes[i]=MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
11675 hid_t item_type0;
11676 hsize_t shape01=shape[0];
11677 hid_t item_type1key;
11678 item_type1key=CreateFLStrType(shape[1]);
11679 hid_t item_type1val;
11680 hid_t item_type2elem;
11681 hid_t item_type3first;
11682 item_type3first=H5T_NATIVE_INT;
11683 hid_t item_type3second;
11684 hid_t item_type4first;
11685 item_type4first=sha1_type_;
11686 hid_t item_type4second;
11687 item_type4second=sha1_type_;
11688 hid_t item_type4secondcompound;
11689 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11690 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11691 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11692 hid_t item_type3elemcompound;
11693 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11694 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11695 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11696 item_type1val=sha1_type_;
11697 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
11698 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
11699 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
11700
11701 }
11702 hid_t item_type1compound;
11703 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11704 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11705 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11706 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11707 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11708 field_types[i]=item_type0;
11709 opened_types_.insert(item_type4secondcompound);
11710 opened_types_.insert(item_type3elemcompound);
11711 opened_types_.insert(item_type1val);
11712 opened_types_.insert(item_type1compound);
11713 opened_types_.insert(field_types[i]);
11714
11715 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
11716 dbtypes[i]=MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
11717 hid_t item_type0;
11718 hsize_t shape01=shape[0];
11719 hid_t item_type1key;
11720 item_type1key=CreateFLStrType(shape[1]);
11721 hid_t item_type1val;
11722 hid_t item_type2elem;
11723 hid_t item_type3first;
11724 item_type3first=H5T_NATIVE_INT;
11725 hid_t item_type3second;
11726 hid_t item_type4first;
11727 item_type4first=sha1_type_;
11728 hid_t item_type4second;
11729 item_type4second=sha1_type_;
11730 hid_t item_type4secondcompound;
11731 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11732 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11733 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11734 hid_t item_type3elemcompound;
11735 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11736 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11737 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11738 item_type1val=sha1_type_;
11739 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
11740 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11741 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
11742
11743 }
11744 hid_t item_type1compound;
11745 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11746 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11747 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11748 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11749 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11750 field_types[i]=item_type0;
11751 opened_types_.insert(item_type4secondcompound);
11752 opened_types_.insert(item_type3elemcompound);
11753 opened_types_.insert(item_type1val);
11754 opened_types_.insert(item_type1compound);
11755 opened_types_.insert(field_types[i]);
11756
11757 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]>=1){
11758 dbtypes[i]=MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING;
11759 hid_t item_type0;
11760 hsize_t shape01=shape[0];
11761 hid_t item_type1key;
11762 item_type1key=sha1_type_;
11763 hid_t item_type1val;
11764 hsize_t shape02=shape[2];
11765 hid_t item_type2elem;
11766 hid_t item_type3first;
11767 item_type3first=H5T_NATIVE_INT;
11768 hid_t item_type3second;
11769 hid_t item_type4first;
11770 item_type4first=CreateFLStrType(shape[6]);
11771 hid_t item_type4second;
11772 item_type4second=CreateFLStrType(shape[7]);
11773 hid_t item_type4secondcompound;
11774 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+shape[7]);
11775 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11776 H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
11777 hid_t item_type3elemcompound;
11778 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+shape[7])));
11779 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11780 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11781 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11782 hid_t item_type1compound;
11783 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]));
11784 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11785 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11786 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11787 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
11788 field_types[i]=item_type0;
11789 opened_types_.insert(item_type4secondcompound);
11790 opened_types_.insert(item_type3elemcompound);
11791 opened_types_.insert(item_type1val);
11792 opened_types_.insert(item_type1compound);
11793 opened_types_.insert(field_types[i]);
11794
11795 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
11796 dbtypes[i]=MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
11797 hid_t item_type0;
11798 hsize_t shape01=shape[0];
11799 hid_t item_type1key;
11800 item_type1key=sha1_type_;
11801 hid_t item_type1val;
11802 hsize_t shape02=shape[2];
11803 hid_t item_type2elem;
11804 hid_t item_type3first;
11805 item_type3first=H5T_NATIVE_INT;
11806 hid_t item_type3second;
11807 hid_t item_type4first;
11808 item_type4first=CreateFLStrType(shape[6]);
11809 hid_t item_type4second;
11810 item_type4second=sha1_type_;
11811 hid_t item_type4secondcompound;
11812 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+CYCLUS_SHA1_SIZE);
11813 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11814 H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
11815 hid_t item_type3elemcompound;
11816 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)));
11817 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11818 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11819 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11820 hid_t item_type1compound;
11821 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]));
11822 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11823 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11824 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11825 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11826 field_types[i]=item_type0;
11827 opened_types_.insert(item_type4secondcompound);
11828 opened_types_.insert(item_type3elemcompound);
11829 opened_types_.insert(item_type1val);
11830 opened_types_.insert(item_type1compound);
11831 opened_types_.insert(field_types[i]);
11832
11833 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
11834 dbtypes[i]=MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
11835 hid_t item_type0;
11836 hsize_t shape01=shape[0];
11837 hid_t item_type1key;
11838 item_type1key=sha1_type_;
11839 hid_t item_type1val;
11840 hsize_t shape02=shape[2];
11841 hid_t item_type2elem;
11842 hid_t item_type3first;
11843 item_type3first=H5T_NATIVE_INT;
11844 hid_t item_type3second;
11845 hid_t item_type4first;
11846 item_type4first=sha1_type_;
11847 hid_t item_type4second;
11848 item_type4second=CreateFLStrType(shape[7]);
11849 hid_t item_type4secondcompound;
11850 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[7]);
11851 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11852 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11853 hid_t item_type3elemcompound;
11854 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])));
11855 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11856 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11857 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11858 hid_t item_type1compound;
11859 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]));
11860 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11861 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11862 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11863 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
11864 field_types[i]=item_type0;
11865 opened_types_.insert(item_type4secondcompound);
11866 opened_types_.insert(item_type3elemcompound);
11867 opened_types_.insert(item_type1val);
11868 opened_types_.insert(item_type1compound);
11869 opened_types_.insert(field_types[i]);
11870
11871 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
11872 dbtypes[i]=MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
11873 hid_t item_type0;
11874 hsize_t shape01=shape[0];
11875 hid_t item_type1key;
11876 item_type1key=sha1_type_;
11877 hid_t item_type1val;
11878 hsize_t shape02=shape[2];
11879 hid_t item_type2elem;
11880 hid_t item_type3first;
11881 item_type3first=H5T_NATIVE_INT;
11882 hid_t item_type3second;
11883 hid_t item_type4first;
11884 item_type4first=sha1_type_;
11885 hid_t item_type4second;
11886 item_type4second=sha1_type_;
11887 hid_t item_type4secondcompound;
11888 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11889 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11890 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11891 hid_t item_type3elemcompound;
11892 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11893 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11894 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11895 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11896 hid_t item_type1compound;
11897 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]));
11898 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11899 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11900 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11901 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11902 field_types[i]=item_type0;
11903 opened_types_.insert(item_type4secondcompound);
11904 opened_types_.insert(item_type3elemcompound);
11905 opened_types_.insert(item_type1val);
11906 opened_types_.insert(item_type1compound);
11907 opened_types_.insert(field_types[i]);
11908
11909 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
11910 dbtypes[i]=MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING;
11911 hid_t item_type0;
11912 hsize_t shape01=shape[0];
11913 hid_t item_type1key;
11914 item_type1key=sha1_type_;
11915 hid_t item_type1val;
11916 hid_t item_type2elem;
11917 hid_t item_type3first;
11918 item_type3first=H5T_NATIVE_INT;
11919 hid_t item_type3second;
11920 hid_t item_type4first;
11921 item_type4first=sha1_type_;
11922 hid_t item_type4second;
11923 item_type4second=sha1_type_;
11924 hid_t item_type4secondcompound;
11925 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11926 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11927 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11928 hid_t item_type3elemcompound;
11929 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11930 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11931 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11932 item_type1val=sha1_type_;
11933 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
11934 vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
11935 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
11936
11937 }
11938 hid_t item_type1compound;
11939 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
11940 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11941 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11942 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11943 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
11944 field_types[i]=item_type0;
11945 opened_types_.insert(item_type4secondcompound);
11946 opened_types_.insert(item_type3elemcompound);
11947 opened_types_.insert(item_type1val);
11948 opened_types_.insert(item_type1compound);
11949 opened_types_.insert(field_types[i]);
11950
11951 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
11952 dbtypes[i]=MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
11953 hid_t item_type0;
11954 hsize_t shape01=shape[0];
11955 hid_t item_type1key;
11956 item_type1key=sha1_type_;
11957 hid_t item_type1val;
11958 hid_t item_type2elem;
11959 hid_t item_type3first;
11960 item_type3first=H5T_NATIVE_INT;
11961 hid_t item_type3second;
11962 hid_t item_type4first;
11963 item_type4first=sha1_type_;
11964 hid_t item_type4second;
11965 item_type4second=sha1_type_;
11966 hid_t item_type4secondcompound;
11967 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11968 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11969 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11970 hid_t item_type3elemcompound;
11971 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11972 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11973 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11974 item_type1val=sha1_type_;
11975 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
11976 vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11977 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
11978
11979 }
11980 hid_t item_type1compound;
11981 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
11982 H5Tinsert(item_type1compound, "key", 0, item_type1key);
11983 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11984 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11985 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
11986 field_types[i]=item_type0;
11987 opened_types_.insert(item_type4secondcompound);
11988 opened_types_.insert(item_type3elemcompound);
11989 opened_types_.insert(item_type1val);
11990 opened_types_.insert(item_type1compound);
11991 opened_types_.insert(field_types[i]);
11992
11993 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
11994 dbtypes[i]=MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
11995 hid_t item_type0;
11996 hsize_t shape01=shape[0];
11997 hid_t item_type1key;
11998 item_type1key=sha1_type_;
11999 hid_t item_type1val;
12000 hid_t item_type2elem;
12001 hid_t item_type3first;
12002 item_type3first=H5T_NATIVE_INT;
12003 hid_t item_type3second;
12004 hid_t item_type4first;
12005 item_type4first=sha1_type_;
12006 hid_t item_type4second;
12007 item_type4second=sha1_type_;
12008 hid_t item_type4secondcompound;
12009 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12010 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12011 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12012 hid_t item_type3elemcompound;
12013 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12014 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12015 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12016 item_type1val=sha1_type_;
12017 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
12018 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
12019 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12020
12021 }
12022 hid_t item_type1compound;
12023 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12024 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12025 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12026 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12027 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
12028 field_types[i]=item_type0;
12029 opened_types_.insert(item_type4secondcompound);
12030 opened_types_.insert(item_type3elemcompound);
12031 opened_types_.insert(item_type1val);
12032 opened_types_.insert(item_type1compound);
12033 opened_types_.insert(field_types[i]);
12034
12035 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
12036 dbtypes[i]=MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
12037 hid_t item_type0;
12038 hsize_t shape01=shape[0];
12039 hid_t item_type1key;
12040 item_type1key=sha1_type_;
12041 hid_t item_type1val;
12042 hid_t item_type2elem;
12043 hid_t item_type3first;
12044 item_type3first=H5T_NATIVE_INT;
12045 hid_t item_type3second;
12046 hid_t item_type4first;
12047 item_type4first=sha1_type_;
12048 hid_t item_type4second;
12049 item_type4second=sha1_type_;
12050 hid_t item_type4secondcompound;
12051 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12052 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12053 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12054 hid_t item_type3elemcompound;
12055 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12056 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12057 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12058 item_type1val=sha1_type_;
12059 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12060 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12061 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12062
12063 }
12064 hid_t item_type1compound;
12065 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12066 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12067 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12068 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12069 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
12070 field_types[i]=item_type0;
12071 opened_types_.insert(item_type4secondcompound);
12072 opened_types_.insert(item_type3elemcompound);
12073 opened_types_.insert(item_type1val);
12074 opened_types_.insert(item_type1compound);
12075 opened_types_.insert(field_types[i]);
12076
12077 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]>=1&&shape[7]>=1){
12078 dbtypes[i]=VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING;
12079 hid_t item_type0;
12080 hid_t item_type1key;
12081 item_type1key=sha1_type_;
12082 hid_t item_type1val;
12083 hsize_t shape02=shape[2];
12084 hid_t item_type2elem;
12085 hid_t item_type3first;
12086 item_type3first=H5T_NATIVE_INT;
12087 hid_t item_type3second;
12088 hid_t item_type4first;
12089 item_type4first=sha1_type_;
12090 hid_t item_type4second;
12091 item_type4second=sha1_type_;
12092 hid_t item_type4secondcompound;
12093 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12094 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12095 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12096 hid_t item_type3elemcompound;
12097 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12098 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12099 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12100 item_type1val=sha1_type_;
12101 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12102 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12103 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12104
12105 }
12106 hid_t item_type1compound;
12107 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12108 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12109 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12110 item_type0=sha1_type_;
12111 if(vldts_.count(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
12112 vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12113 opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12114
12115 }
12116 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12117 field_types[i]=sha1_type_;
12118
12119 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
12120 dbtypes[i]=VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
12121 hid_t item_type0;
12122 hid_t item_type1key;
12123 item_type1key=sha1_type_;
12124 hid_t item_type1val;
12125 hsize_t shape02=shape[2];
12126 hid_t item_type2elem;
12127 hid_t item_type3first;
12128 item_type3first=H5T_NATIVE_INT;
12129 hid_t item_type3second;
12130 hid_t item_type4first;
12131 item_type4first=sha1_type_;
12132 hid_t item_type4second;
12133 item_type4second=sha1_type_;
12134 hid_t item_type4secondcompound;
12135 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12136 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12137 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12138 hid_t item_type3elemcompound;
12139 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12140 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12141 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12142 item_type1val=sha1_type_;
12143 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12144 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12145 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12146
12147 }
12148 hid_t item_type1compound;
12149 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12150 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12151 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12152 item_type0=sha1_type_;
12153 if(vldts_.count(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
12154 vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12155 opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12156
12157 }
12158 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12159 field_types[i]=sha1_type_;
12160
12161 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
12162 dbtypes[i]=VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
12163 hid_t item_type0;
12164 hid_t item_type1key;
12165 item_type1key=sha1_type_;
12166 hid_t item_type1val;
12167 hsize_t shape02=shape[2];
12168 hid_t item_type2elem;
12169 hid_t item_type3first;
12170 item_type3first=H5T_NATIVE_INT;
12171 hid_t item_type3second;
12172 hid_t item_type4first;
12173 item_type4first=sha1_type_;
12174 hid_t item_type4second;
12175 item_type4second=sha1_type_;
12176 hid_t item_type4secondcompound;
12177 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12178 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12179 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12180 hid_t item_type3elemcompound;
12181 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12182 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12183 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12184 item_type1val=sha1_type_;
12185 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12186 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12187 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12188
12189 }
12190 hid_t item_type1compound;
12191 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12192 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12193 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12194 item_type0=sha1_type_;
12195 if(vldts_.count(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
12196 vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12197 opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12198
12199 }
12200 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12201 field_types[i]=sha1_type_;
12202
12203 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
12204 dbtypes[i]=VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
12205 hid_t item_type0;
12206 hid_t item_type1key;
12207 item_type1key=sha1_type_;
12208 hid_t item_type1val;
12209 hsize_t shape02=shape[2];
12210 hid_t item_type2elem;
12211 hid_t item_type3first;
12212 item_type3first=H5T_NATIVE_INT;
12213 hid_t item_type3second;
12214 hid_t item_type4first;
12215 item_type4first=sha1_type_;
12216 hid_t item_type4second;
12217 item_type4second=sha1_type_;
12218 hid_t item_type4secondcompound;
12219 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12220 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12221 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12222 hid_t item_type3elemcompound;
12223 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12224 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12225 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12226 item_type1val=sha1_type_;
12227 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12228 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12229 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12230
12231 }
12232 hid_t item_type1compound;
12233 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12234 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12235 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12236 item_type0=sha1_type_;
12237 if(vldts_.count(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12238 vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12239 opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12240
12241 }
12242 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12243 field_types[i]=sha1_type_;
12244
12245 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
12246 dbtypes[i]=VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING;
12247 hid_t item_type0;
12248 hid_t item_type1key;
12249 item_type1key=sha1_type_;
12250 hid_t item_type1val;
12251 hid_t item_type2elem;
12252 hid_t item_type3first;
12253 item_type3first=H5T_NATIVE_INT;
12254 hid_t item_type3second;
12255 hid_t item_type4first;
12256 item_type4first=sha1_type_;
12257 hid_t item_type4second;
12258 item_type4second=sha1_type_;
12259 hid_t item_type4secondcompound;
12260 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12261 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12262 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12263 hid_t item_type3elemcompound;
12264 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12265 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12266 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12267 item_type1val=sha1_type_;
12268 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12269 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12270 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12271
12272 }
12273 hid_t item_type1compound;
12274 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12275 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12276 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12277 item_type0=sha1_type_;
12278 if(vldts_.count(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
12279 vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12280 opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12281
12282 }
12283 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12284 field_types[i]=sha1_type_;
12285
12286 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
12287 dbtypes[i]=VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
12288 hid_t item_type0;
12289 hid_t item_type1key;
12290 item_type1key=sha1_type_;
12291 hid_t item_type1val;
12292 hid_t item_type2elem;
12293 hid_t item_type3first;
12294 item_type3first=H5T_NATIVE_INT;
12295 hid_t item_type3second;
12296 hid_t item_type4first;
12297 item_type4first=sha1_type_;
12298 hid_t item_type4second;
12299 item_type4second=sha1_type_;
12300 hid_t item_type4secondcompound;
12301 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12302 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12303 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12304 hid_t item_type3elemcompound;
12305 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12306 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12307 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12308 item_type1val=sha1_type_;
12309 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12310 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12311 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12312
12313 }
12314 hid_t item_type1compound;
12315 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12316 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12317 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12318 item_type0=sha1_type_;
12319 if(vldts_.count(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
12320 vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12321 opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12322
12323 }
12324 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12325 field_types[i]=sha1_type_;
12326
12327 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
12328 dbtypes[i]=VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
12329 hid_t item_type0;
12330 hid_t item_type1key;
12331 item_type1key=sha1_type_;
12332 hid_t item_type1val;
12333 hid_t item_type2elem;
12334 hid_t item_type3first;
12335 item_type3first=H5T_NATIVE_INT;
12336 hid_t item_type3second;
12337 hid_t item_type4first;
12338 item_type4first=sha1_type_;
12339 hid_t item_type4second;
12340 item_type4second=sha1_type_;
12341 hid_t item_type4secondcompound;
12342 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12343 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12344 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12345 hid_t item_type3elemcompound;
12346 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12347 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12348 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12349 item_type1val=sha1_type_;
12350 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12351 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12352 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12353
12354 }
12355 hid_t item_type1compound;
12356 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12357 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12358 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12359 item_type0=sha1_type_;
12360 if(vldts_.count(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
12361 vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12362 opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12363
12364 }
12365 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12366 field_types[i]=sha1_type_;
12367
12368 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
12369 dbtypes[i]=VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
12370 hid_t item_type0;
12371 hid_t item_type1key;
12372 item_type1key=sha1_type_;
12373 hid_t item_type1val;
12374 hid_t item_type2elem;
12375 hid_t item_type3first;
12376 item_type3first=H5T_NATIVE_INT;
12377 hid_t item_type3second;
12378 hid_t item_type4first;
12379 item_type4first=sha1_type_;
12380 hid_t item_type4second;
12381 item_type4second=sha1_type_;
12382 hid_t item_type4secondcompound;
12383 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12384 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12385 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12386 hid_t item_type3elemcompound;
12387 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12388 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12389 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12390 item_type1val=sha1_type_;
12391 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12392 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12393 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12394
12395 }
12396 hid_t item_type1compound;
12397 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12398 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12399 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12400 item_type0=sha1_type_;
12401 if(vldts_.count(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12402 vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12403 opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12404
12405 }
12406 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12407 field_types[i]=sha1_type_;
12408
12409 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]>=1){
12410 dbtypes[i]=VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING;
12411 hid_t item_type0;
12412 hid_t item_type1key;
12413 item_type1key=sha1_type_;
12414 hid_t item_type1val;
12415 hsize_t shape02=shape[2];
12416 hid_t item_type2elem;
12417 hid_t item_type3first;
12418 item_type3first=H5T_NATIVE_INT;
12419 hid_t item_type3second;
12420 hid_t item_type4first;
12421 item_type4first=sha1_type_;
12422 hid_t item_type4second;
12423 item_type4second=sha1_type_;
12424 hid_t item_type4secondcompound;
12425 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12426 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12427 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12428 hid_t item_type3elemcompound;
12429 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12430 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12431 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12432 item_type1val=sha1_type_;
12433 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12434 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12435 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12436
12437 }
12438 hid_t item_type1compound;
12439 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12440 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12441 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12442 item_type0=sha1_type_;
12443 if(vldts_.count(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
12444 vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12445 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12446
12447 }
12448 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12449 field_types[i]=sha1_type_;
12450
12451 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
12452 dbtypes[i]=VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
12453 hid_t item_type0;
12454 hid_t item_type1key;
12455 item_type1key=sha1_type_;
12456 hid_t item_type1val;
12457 hsize_t shape02=shape[2];
12458 hid_t item_type2elem;
12459 hid_t item_type3first;
12460 item_type3first=H5T_NATIVE_INT;
12461 hid_t item_type3second;
12462 hid_t item_type4first;
12463 item_type4first=sha1_type_;
12464 hid_t item_type4second;
12465 item_type4second=sha1_type_;
12466 hid_t item_type4secondcompound;
12467 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12468 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12469 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12470 hid_t item_type3elemcompound;
12471 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12472 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12473 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12474 item_type1val=sha1_type_;
12475 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12476 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12477 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12478
12479 }
12480 hid_t item_type1compound;
12481 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12482 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12483 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12484 item_type0=sha1_type_;
12485 if(vldts_.count(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
12486 vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12487 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12488
12489 }
12490 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12491 field_types[i]=sha1_type_;
12492
12493 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
12494 dbtypes[i]=VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
12495 hid_t item_type0;
12496 hid_t item_type1key;
12497 item_type1key=sha1_type_;
12498 hid_t item_type1val;
12499 hsize_t shape02=shape[2];
12500 hid_t item_type2elem;
12501 hid_t item_type3first;
12502 item_type3first=H5T_NATIVE_INT;
12503 hid_t item_type3second;
12504 hid_t item_type4first;
12505 item_type4first=sha1_type_;
12506 hid_t item_type4second;
12507 item_type4second=sha1_type_;
12508 hid_t item_type4secondcompound;
12509 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12510 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12511 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12512 hid_t item_type3elemcompound;
12513 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12514 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12515 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12516 item_type1val=sha1_type_;
12517 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12518 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12519 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12520
12521 }
12522 hid_t item_type1compound;
12523 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12524 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12525 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12526 item_type0=sha1_type_;
12527 if(vldts_.count(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
12528 vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12529 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12530
12531 }
12532 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12533 field_types[i]=sha1_type_;
12534
12535 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
12536 dbtypes[i]=VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
12537 hid_t item_type0;
12538 hid_t item_type1key;
12539 item_type1key=sha1_type_;
12540 hid_t item_type1val;
12541 hsize_t shape02=shape[2];
12542 hid_t item_type2elem;
12543 hid_t item_type3first;
12544 item_type3first=H5T_NATIVE_INT;
12545 hid_t item_type3second;
12546 hid_t item_type4first;
12547 item_type4first=sha1_type_;
12548 hid_t item_type4second;
12549 item_type4second=sha1_type_;
12550 hid_t item_type4secondcompound;
12551 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12552 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12553 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12554 hid_t item_type3elemcompound;
12555 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12556 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12557 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12558 item_type1val=sha1_type_;
12559 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12560 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12561 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12562
12563 }
12564 hid_t item_type1compound;
12565 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12566 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12567 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12568 item_type0=sha1_type_;
12569 if(vldts_.count(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12570 vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12571 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12572
12573 }
12574 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12575 field_types[i]=sha1_type_;
12576
12577 }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
12578 dbtypes[i]=VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING;
12579 hid_t item_type0;
12580 hid_t item_type1key;
12581 item_type1key=sha1_type_;
12582 hid_t item_type1val;
12583 hid_t item_type2elem;
12584 hid_t item_type3first;
12585 item_type3first=H5T_NATIVE_INT;
12586 hid_t item_type3second;
12587 hid_t item_type4first;
12588 item_type4first=sha1_type_;
12589 hid_t item_type4second;
12590 item_type4second=sha1_type_;
12591 hid_t item_type4secondcompound;
12592 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12593 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12594 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12595 hid_t item_type3elemcompound;
12596 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12597 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12598 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12599 item_type1val=sha1_type_;
12600 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12601 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12602 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12603
12604 }
12605 hid_t item_type1compound;
12606 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12607 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12608 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12609 item_type0=sha1_type_;
12610 if(vldts_.count(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
12611 vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12612 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12613
12614 }
12615 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12616 field_types[i]=sha1_type_;
12617
12618 }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
12619 dbtypes[i]=VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
12620 hid_t item_type0;
12621 hid_t item_type1key;
12622 item_type1key=sha1_type_;
12623 hid_t item_type1val;
12624 hid_t item_type2elem;
12625 hid_t item_type3first;
12626 item_type3first=H5T_NATIVE_INT;
12627 hid_t item_type3second;
12628 hid_t item_type4first;
12629 item_type4first=sha1_type_;
12630 hid_t item_type4second;
12631 item_type4second=sha1_type_;
12632 hid_t item_type4secondcompound;
12633 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12634 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12635 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12636 hid_t item_type3elemcompound;
12637 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12638 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12639 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12640 item_type1val=sha1_type_;
12641 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12642 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12643 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12644
12645 }
12646 hid_t item_type1compound;
12647 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12648 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12649 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12650 item_type0=sha1_type_;
12651 if(vldts_.count(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
12652 vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12653 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12654
12655 }
12656 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12657 field_types[i]=sha1_type_;
12658
12659 }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
12660 dbtypes[i]=VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
12661 hid_t item_type0;
12662 hid_t item_type1key;
12663 item_type1key=sha1_type_;
12664 hid_t item_type1val;
12665 hid_t item_type2elem;
12666 hid_t item_type3first;
12667 item_type3first=H5T_NATIVE_INT;
12668 hid_t item_type3second;
12669 hid_t item_type4first;
12670 item_type4first=sha1_type_;
12671 hid_t item_type4second;
12672 item_type4second=sha1_type_;
12673 hid_t item_type4secondcompound;
12674 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12675 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12676 H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12677 hid_t item_type3elemcompound;
12678 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12679 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12680 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12681 item_type1val=sha1_type_;
12682 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12683 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12684 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12685
12686 }
12687 hid_t item_type1compound;
12688 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12689 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12690 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12691 item_type0=sha1_type_;
12692 if(vldts_.count(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
12693 vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12694 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12695
12696 }
12697 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12698 field_types[i]=sha1_type_;
12699
12700 }else{
12701 dbtypes[i]=MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING;
12702 hid_t item_type0;
12703 hsize_t shape01=shape[0];
12704 hid_t item_type1key;
12705 item_type1key=CreateFLStrType(shape[1]);
12706 hid_t item_type1val;
12707 hsize_t shape02=shape[2];
12708 hid_t item_type2elem;
12709 hid_t item_type3first;
12710 item_type3first=H5T_NATIVE_INT;
12711 hid_t item_type3second;
12712 hid_t item_type4first;
12713 item_type4first=CreateFLStrType(shape[6]);
12714 hid_t item_type4second;
12715 item_type4second=CreateFLStrType(shape[7]);
12716 hid_t item_type4secondcompound;
12717 item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+shape[7]);
12718 H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12719 H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
12720 hid_t item_type3elemcompound;
12721 item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+shape[7])));
12722 H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12723 H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12724 item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
12725 hid_t item_type1compound;
12726 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]));
12727 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12728 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
12729 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12730 dst_sizes[i]=((shape[1]+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
12731 field_types[i]=item_type0;
12732 opened_types_.insert(item_type4secondcompound);
12733 opened_types_.insert(item_type3elemcompound);
12734 opened_types_.insert(item_type1val);
12735 opened_types_.insert(item_type1compound);
12736 opened_types_.insert(field_types[i]);
12737
12738 }
12739
12740 }else if(valtype==typeid(std::list<std::pair<int, int>>)){
12741 shape=shapes[i];
12742 if(shape.empty()||shape[0]<1){
12743 dbtypes[i]=VL_LIST_PAIR_INT_INT;
12744 hid_t item_type0;
12745 hid_t item_type1elem;
12746 hid_t item_type2first;
12747 item_type2first=H5T_NATIVE_INT;
12748 hid_t item_type2second;
12749 item_type2second=H5T_NATIVE_INT;
12750 hid_t item_type2elemcompound;
12751 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
12752 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
12753 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type2second);
12754 item_type0=sha1_type_;
12755 if(vldts_.count(VL_LIST_PAIR_INT_INT)==0){
12756 vldts_[VL_LIST_PAIR_INT_INT]=H5Tvlen_create(item_type2elemcompound);
12757 opened_types_.insert(vldts_[VL_LIST_PAIR_INT_INT]);
12758
12759 }
12760 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12761 field_types[i]=sha1_type_;
12762
12763 }else{
12764 dbtypes[i]=LIST_PAIR_INT_INT;
12765 hid_t item_type0;
12766 hsize_t shape01=shape[0];
12767 hid_t item_type1elem;
12768 hid_t item_type2first;
12769 item_type2first=H5T_NATIVE_INT;
12770 hid_t item_type2second;
12771 item_type2second=H5T_NATIVE_INT;
12772 hid_t item_type2elemcompound;
12773 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
12774 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
12775 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type2second);
12776 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
12777 dst_sizes[i]=((((sizeof(int)+sizeof(int))))*shape[0]);
12778 field_types[i]=item_type0;
12779 opened_types_.insert(item_type2elemcompound);
12780 opened_types_.insert(field_types[i]);
12781
12782 }
12783
12784 }else if(valtype==typeid(std::map<std::string, std::pair<std::string, std::vector<double>>>)){
12785 shape=shapes[i];
12786 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[3]<1&&shape[4]<1){
12787 dbtypes[i]=VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE;
12788 hid_t item_type0;
12789 hid_t item_type1key;
12790 item_type1key=sha1_type_;
12791 hid_t item_type1val;
12792 hid_t item_type2first;
12793 item_type2first=sha1_type_;
12794 hid_t item_type2second;
12795 hid_t item_type3elem;
12796 item_type3elem=H5T_NATIVE_DOUBLE;
12797 item_type2second=sha1_type_;
12798 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12799 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12800 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12801
12802 }
12803 hid_t item_type2valcompound;
12804 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12805 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12806 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12807 hid_t item_type1compound;
12808 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
12809 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12810 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
12811 item_type0=sha1_type_;
12812 if(vldts_.count(VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE)==0){
12813 vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
12814 opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]);
12815
12816 }
12817 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12818 field_types[i]=sha1_type_;
12819
12820 }else if(shape[0]>=1&&shape[1]>=1&&shape[3]>=1&&shape[4]<1){
12821 dbtypes[i]=MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE;
12822 hid_t item_type0;
12823 hsize_t shape01=shape[0];
12824 hid_t item_type1key;
12825 item_type1key=CreateFLStrType(shape[1]);
12826 hid_t item_type1val;
12827 hid_t item_type2first;
12828 item_type2first=CreateFLStrType(shape[3]);
12829 hid_t item_type2second;
12830 hid_t item_type3elem;
12831 item_type3elem=H5T_NATIVE_DOUBLE;
12832 item_type2second=sha1_type_;
12833 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12834 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12835 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12836
12837 }
12838 hid_t item_type2valcompound;
12839 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+(CYCLUS_SHA1_SIZE));
12840 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12841 H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
12842 hid_t item_type1compound;
12843 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+(CYCLUS_SHA1_SIZE))));
12844 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12845 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
12846 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12847 dst_sizes[i]=((shape[1]+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
12848 field_types[i]=item_type0;
12849 opened_types_.insert(item_type2second);
12850 opened_types_.insert(item_type2valcompound);
12851 opened_types_.insert(item_type1compound);
12852 opened_types_.insert(field_types[i]);
12853
12854 }else if(shape[0]>=1&&shape[1]>=1&&shape[3]<1&&shape[4]>=1){
12855 dbtypes[i]=MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE;
12856 hid_t item_type0;
12857 hsize_t shape01=shape[0];
12858 hid_t item_type1key;
12859 item_type1key=CreateFLStrType(shape[1]);
12860 hid_t item_type1val;
12861 hid_t item_type2first;
12862 item_type2first=sha1_type_;
12863 hid_t item_type2second;
12864 hsize_t shape03=shape[4];
12865 hid_t item_type3elem;
12866 item_type3elem=H5T_NATIVE_DOUBLE;
12867 item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
12868 hid_t item_type2valcompound;
12869 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]));
12870 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12871 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12872 hid_t item_type1compound;
12873 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))));
12874 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12875 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
12876 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12877 dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
12878 field_types[i]=item_type0;
12879 opened_types_.insert(item_type2second);
12880 opened_types_.insert(item_type2valcompound);
12881 opened_types_.insert(item_type1compound);
12882 opened_types_.insert(field_types[i]);
12883
12884 }else if(shape[0]>=1&&shape[1]>=1&&shape[3]<1&&shape[4]<1){
12885 dbtypes[i]=MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE;
12886 hid_t item_type0;
12887 hsize_t shape01=shape[0];
12888 hid_t item_type1key;
12889 item_type1key=CreateFLStrType(shape[1]);
12890 hid_t item_type1val;
12891 hid_t item_type2first;
12892 item_type2first=sha1_type_;
12893 hid_t item_type2second;
12894 hid_t item_type3elem;
12895 item_type3elem=H5T_NATIVE_DOUBLE;
12896 item_type2second=sha1_type_;
12897 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12898 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12899 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12900
12901 }
12902 hid_t item_type2valcompound;
12903 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12904 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12905 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12906 hid_t item_type1compound;
12907 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
12908 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12909 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
12910 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12911 dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
12912 field_types[i]=item_type0;
12913 opened_types_.insert(item_type2second);
12914 opened_types_.insert(item_type2valcompound);
12915 opened_types_.insert(item_type1compound);
12916 opened_types_.insert(field_types[i]);
12917
12918 }else if(shape[0]>=1&&shape[1]<1&&shape[3]>=1&&shape[4]>=1){
12919 dbtypes[i]=MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE;
12920 hid_t item_type0;
12921 hsize_t shape01=shape[0];
12922 hid_t item_type1key;
12923 item_type1key=sha1_type_;
12924 hid_t item_type1val;
12925 hid_t item_type2first;
12926 item_type2first=CreateFLStrType(shape[3]);
12927 hid_t item_type2second;
12928 hsize_t shape03=shape[4];
12929 hid_t item_type3elem;
12930 item_type3elem=H5T_NATIVE_DOUBLE;
12931 item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
12932 hid_t item_type2valcompound;
12933 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+((sizeof(double))*shape[4]));
12934 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12935 H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
12936 hid_t item_type1compound;
12937 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+((sizeof(double))*shape[4]))));
12938 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12939 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
12940 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12941 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
12942 field_types[i]=item_type0;
12943 opened_types_.insert(item_type2second);
12944 opened_types_.insert(item_type2valcompound);
12945 opened_types_.insert(item_type1compound);
12946 opened_types_.insert(field_types[i]);
12947
12948 }else if(shape[0]>=1&&shape[1]<1&&shape[3]<1&&shape[4]>=1){
12949 dbtypes[i]=MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE;
12950 hid_t item_type0;
12951 hsize_t shape01=shape[0];
12952 hid_t item_type1key;
12953 item_type1key=sha1_type_;
12954 hid_t item_type1val;
12955 hid_t item_type2first;
12956 item_type2first=sha1_type_;
12957 hid_t item_type2second;
12958 hsize_t shape03=shape[4];
12959 hid_t item_type3elem;
12960 item_type3elem=H5T_NATIVE_DOUBLE;
12961 item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
12962 hid_t item_type2valcompound;
12963 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]));
12964 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12965 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12966 hid_t item_type1compound;
12967 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))));
12968 H5Tinsert(item_type1compound, "key", 0, item_type1key);
12969 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
12970 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12971 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
12972 field_types[i]=item_type0;
12973 opened_types_.insert(item_type2second);
12974 opened_types_.insert(item_type2valcompound);
12975 opened_types_.insert(item_type1compound);
12976 opened_types_.insert(field_types[i]);
12977
12978 }else if(shape[0]>=1&&shape[1]<1&&shape[3]>=1&&shape[4]<1){
12979 dbtypes[i]=MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE;
12980 hid_t item_type0;
12981 hsize_t shape01=shape[0];
12982 hid_t item_type1key;
12983 item_type1key=sha1_type_;
12984 hid_t item_type1val;
12985 hid_t item_type2first;
12986 item_type2first=CreateFLStrType(shape[3]);
12987 hid_t item_type2second;
12988 hid_t item_type3elem;
12989 item_type3elem=H5T_NATIVE_DOUBLE;
12990 item_type2second=sha1_type_;
12991 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12992 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12993 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12994
12995 }
12996 hid_t item_type2valcompound;
12997 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+(CYCLUS_SHA1_SIZE));
12998 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12999 H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
13000 hid_t item_type1compound;
13001 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+(CYCLUS_SHA1_SIZE))));
13002 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13003 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13004 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13005 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
13006 field_types[i]=item_type0;
13007 opened_types_.insert(item_type2second);
13008 opened_types_.insert(item_type2valcompound);
13009 opened_types_.insert(item_type1compound);
13010 opened_types_.insert(field_types[i]);
13011
13012 }else if(shape[0]>=1&&shape[1]<1&&shape[3]<1&&shape[4]<1){
13013 dbtypes[i]=MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE;
13014 hid_t item_type0;
13015 hsize_t shape01=shape[0];
13016 hid_t item_type1key;
13017 item_type1key=sha1_type_;
13018 hid_t item_type1val;
13019 hid_t item_type2first;
13020 item_type2first=sha1_type_;
13021 hid_t item_type2second;
13022 hid_t item_type3elem;
13023 item_type3elem=H5T_NATIVE_DOUBLE;
13024 item_type2second=sha1_type_;
13025 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13026 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13027 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13028
13029 }
13030 hid_t item_type2valcompound;
13031 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13032 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13033 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13034 hid_t item_type1compound;
13035 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13036 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13037 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13038 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13039 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
13040 field_types[i]=item_type0;
13041 opened_types_.insert(item_type2second);
13042 opened_types_.insert(item_type2valcompound);
13043 opened_types_.insert(item_type1compound);
13044 opened_types_.insert(field_types[i]);
13045
13046 }else if(shape[0]<1&&shape[1]>=1&&shape[3]>=1&&shape[4]>=1){
13047 dbtypes[i]=VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE;
13048 hid_t item_type0;
13049 hid_t item_type1key;
13050 item_type1key=sha1_type_;
13051 hid_t item_type1val;
13052 hid_t item_type2first;
13053 item_type2first=sha1_type_;
13054 hid_t item_type2second;
13055 hsize_t shape03=shape[4];
13056 hid_t item_type3elem;
13057 item_type3elem=H5T_NATIVE_DOUBLE;
13058 item_type2second=sha1_type_;
13059 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13060 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13061 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13062
13063 }
13064 hid_t item_type2valcompound;
13065 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13066 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13067 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13068 hid_t item_type1compound;
13069 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13070 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13071 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13072 item_type0=sha1_type_;
13073 if(vldts_.count(VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE)==0){
13074 vldts_[VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13075 opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE]);
13076
13077 }
13078 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13079 field_types[i]=sha1_type_;
13080
13081 }else if(shape[0]<1&&shape[1]<1&&shape[3]>=1&&shape[4]>=1){
13082 dbtypes[i]=VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE;
13083 hid_t item_type0;
13084 hid_t item_type1key;
13085 item_type1key=sha1_type_;
13086 hid_t item_type1val;
13087 hid_t item_type2first;
13088 item_type2first=sha1_type_;
13089 hid_t item_type2second;
13090 hsize_t shape03=shape[4];
13091 hid_t item_type3elem;
13092 item_type3elem=H5T_NATIVE_DOUBLE;
13093 item_type2second=sha1_type_;
13094 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13095 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13096 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13097
13098 }
13099 hid_t item_type2valcompound;
13100 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13101 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13102 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13103 hid_t item_type1compound;
13104 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13105 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13106 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13107 item_type0=sha1_type_;
13108 if(vldts_.count(VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE)==0){
13109 vldts_[VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13110 opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE]);
13111
13112 }
13113 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13114 field_types[i]=sha1_type_;
13115
13116 }else if(shape[0]<1&&shape[1]>=1&&shape[3]<1&&shape[4]>=1){
13117 dbtypes[i]=VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE;
13118 hid_t item_type0;
13119 hid_t item_type1key;
13120 item_type1key=sha1_type_;
13121 hid_t item_type1val;
13122 hid_t item_type2first;
13123 item_type2first=sha1_type_;
13124 hid_t item_type2second;
13125 hsize_t shape03=shape[4];
13126 hid_t item_type3elem;
13127 item_type3elem=H5T_NATIVE_DOUBLE;
13128 item_type2second=sha1_type_;
13129 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13130 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13131 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13132
13133 }
13134 hid_t item_type2valcompound;
13135 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13136 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13137 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13138 hid_t item_type1compound;
13139 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13140 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13141 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13142 item_type0=sha1_type_;
13143 if(vldts_.count(VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE)==0){
13144 vldts_[VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13145 opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]);
13146
13147 }
13148 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13149 field_types[i]=sha1_type_;
13150
13151 }else if(shape[0]<1&&shape[1]>=1&&shape[3]>=1&&shape[4]<1){
13152 dbtypes[i]=VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE;
13153 hid_t item_type0;
13154 hid_t item_type1key;
13155 item_type1key=sha1_type_;
13156 hid_t item_type1val;
13157 hid_t item_type2first;
13158 item_type2first=sha1_type_;
13159 hid_t item_type2second;
13160 hid_t item_type3elem;
13161 item_type3elem=H5T_NATIVE_DOUBLE;
13162 item_type2second=sha1_type_;
13163 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13164 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13165 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13166
13167 }
13168 hid_t item_type2valcompound;
13169 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13170 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13171 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13172 hid_t item_type1compound;
13173 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13174 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13175 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13176 item_type0=sha1_type_;
13177 if(vldts_.count(VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE)==0){
13178 vldts_[VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13179 opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]);
13180
13181 }
13182 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13183 field_types[i]=sha1_type_;
13184
13185 }else if(shape[0]<1&&shape[1]<1&&shape[3]<1&&shape[4]>=1){
13186 dbtypes[i]=VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE;
13187 hid_t item_type0;
13188 hid_t item_type1key;
13189 item_type1key=sha1_type_;
13190 hid_t item_type1val;
13191 hid_t item_type2first;
13192 item_type2first=sha1_type_;
13193 hid_t item_type2second;
13194 hsize_t shape03=shape[4];
13195 hid_t item_type3elem;
13196 item_type3elem=H5T_NATIVE_DOUBLE;
13197 item_type2second=sha1_type_;
13198 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13199 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13200 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13201
13202 }
13203 hid_t item_type2valcompound;
13204 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13205 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13206 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13207 hid_t item_type1compound;
13208 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13209 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13210 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13211 item_type0=sha1_type_;
13212 if(vldts_.count(VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE)==0){
13213 vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13214 opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]);
13215
13216 }
13217 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13218 field_types[i]=sha1_type_;
13219
13220 }else if(shape[0]<1&&shape[1]<1&&shape[3]>=1&&shape[4]<1){
13221 dbtypes[i]=VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE;
13222 hid_t item_type0;
13223 hid_t item_type1key;
13224 item_type1key=sha1_type_;
13225 hid_t item_type1val;
13226 hid_t item_type2first;
13227 item_type2first=sha1_type_;
13228 hid_t item_type2second;
13229 hid_t item_type3elem;
13230 item_type3elem=H5T_NATIVE_DOUBLE;
13231 item_type2second=sha1_type_;
13232 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13233 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13234 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13235
13236 }
13237 hid_t item_type2valcompound;
13238 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13239 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13240 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13241 hid_t item_type1compound;
13242 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13243 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13244 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13245 item_type0=sha1_type_;
13246 if(vldts_.count(VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE)==0){
13247 vldts_[VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13248 opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]);
13249
13250 }
13251 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13252 field_types[i]=sha1_type_;
13253
13254 }else if(shape[0]<1&&shape[1]>=1&&shape[3]<1&&shape[4]<1){
13255 dbtypes[i]=VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE;
13256 hid_t item_type0;
13257 hid_t item_type1key;
13258 item_type1key=sha1_type_;
13259 hid_t item_type1val;
13260 hid_t item_type2first;
13261 item_type2first=sha1_type_;
13262 hid_t item_type2second;
13263 hid_t item_type3elem;
13264 item_type3elem=H5T_NATIVE_DOUBLE;
13265 item_type2second=sha1_type_;
13266 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13267 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13268 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13269
13270 }
13271 hid_t item_type2valcompound;
13272 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13273 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13274 H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13275 hid_t item_type1compound;
13276 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13277 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13278 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13279 item_type0=sha1_type_;
13280 if(vldts_.count(VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE)==0){
13281 vldts_[VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13282 opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]);
13283
13284 }
13285 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13286 field_types[i]=sha1_type_;
13287
13288 }else{
13289 dbtypes[i]=MAP_STRING_PAIR_STRING_VECTOR_DOUBLE;
13290 hid_t item_type0;
13291 hsize_t shape01=shape[0];
13292 hid_t item_type1key;
13293 item_type1key=CreateFLStrType(shape[1]);
13294 hid_t item_type1val;
13295 hid_t item_type2first;
13296 item_type2first=CreateFLStrType(shape[3]);
13297 hid_t item_type2second;
13298 hsize_t shape03=shape[4];
13299 hid_t item_type3elem;
13300 item_type3elem=H5T_NATIVE_DOUBLE;
13301 item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
13302 hid_t item_type2valcompound;
13303 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+((sizeof(double))*shape[4]));
13304 H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13305 H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
13306 hid_t item_type1compound;
13307 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+((sizeof(double))*shape[4]))));
13308 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13309 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
13310 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13311 dst_sizes[i]=((shape[1]+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
13312 field_types[i]=item_type0;
13313 opened_types_.insert(item_type2second);
13314 opened_types_.insert(item_type2valcompound);
13315 opened_types_.insert(item_type1compound);
13316 opened_types_.insert(field_types[i]);
13317
13318 }
13319
13320 }else if(valtype==typeid(std::map<std::string, std::map<std::string, int>>)){
13321 shape=shapes[i];
13322 if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
13323 dbtypes[i]=VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT;
13324 hid_t item_type0;
13325 hid_t item_type1key;
13326 item_type1key=sha1_type_;
13327 hid_t item_type1val;
13328 hid_t item_type2key;
13329 item_type2key=sha1_type_;
13330 hid_t item_type2val;
13331 item_type2val=H5T_NATIVE_INT;
13332 hid_t item_type2valcompound;
13333 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13334 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13335 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13336 item_type1val=sha1_type_;
13337 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13338 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13339 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13340
13341 }
13342 hid_t item_type1compound;
13343 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13344 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13345 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13346 item_type0=sha1_type_;
13347 if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT)==0){
13348 vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13349 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT]);
13350
13351 }
13352 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13353 field_types[i]=sha1_type_;
13354
13355 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
13356 dbtypes[i]=MAP_STRING_MAP_VL_STRING_INT;
13357 hid_t item_type0;
13358 hsize_t shape01=shape[0];
13359 hid_t item_type1key;
13360 item_type1key=CreateFLStrType(shape[1]);
13361 hid_t item_type1val;
13362 hsize_t shape02=shape[2];
13363 hid_t item_type2key;
13364 item_type2key=sha1_type_;
13365 hid_t item_type2val;
13366 item_type2val=H5T_NATIVE_INT;
13367 hid_t item_type2valcompound;
13368 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13369 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13370 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13371 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13372 hid_t item_type1compound;
13373 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]));
13374 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13375 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13376 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13377 dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
13378 field_types[i]=item_type0;
13379 opened_types_.insert(item_type2valcompound);
13380 opened_types_.insert(item_type1val);
13381 opened_types_.insert(item_type1compound);
13382 opened_types_.insert(field_types[i]);
13383
13384 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
13385 dbtypes[i]=MAP_STRING_VL_MAP_STRING_INT;
13386 hid_t item_type0;
13387 hsize_t shape01=shape[0];
13388 hid_t item_type1key;
13389 item_type1key=CreateFLStrType(shape[1]);
13390 hid_t item_type1val;
13391 hid_t item_type2key;
13392 item_type2key=sha1_type_;
13393 hid_t item_type2val;
13394 item_type2val=H5T_NATIVE_INT;
13395 hid_t item_type2valcompound;
13396 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13397 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13398 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13399 item_type1val=sha1_type_;
13400 if(vldts_.count(VL_MAP_STRING_INT)==0){
13401 vldts_[VL_MAP_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13402 opened_types_.insert(vldts_[VL_MAP_STRING_INT]);
13403
13404 }
13405 hid_t item_type1compound;
13406 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
13407 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13408 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13409 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13410 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
13411 field_types[i]=item_type0;
13412 opened_types_.insert(item_type2valcompound);
13413 opened_types_.insert(item_type1val);
13414 opened_types_.insert(item_type1compound);
13415 opened_types_.insert(field_types[i]);
13416
13417 }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
13418 dbtypes[i]=MAP_STRING_VL_MAP_VL_STRING_INT;
13419 hid_t item_type0;
13420 hsize_t shape01=shape[0];
13421 hid_t item_type1key;
13422 item_type1key=CreateFLStrType(shape[1]);
13423 hid_t item_type1val;
13424 hid_t item_type2key;
13425 item_type2key=sha1_type_;
13426 hid_t item_type2val;
13427 item_type2val=H5T_NATIVE_INT;
13428 hid_t item_type2valcompound;
13429 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13430 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13431 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13432 item_type1val=sha1_type_;
13433 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13434 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13435 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13436
13437 }
13438 hid_t item_type1compound;
13439 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
13440 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13441 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13442 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13443 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
13444 field_types[i]=item_type0;
13445 opened_types_.insert(item_type2valcompound);
13446 opened_types_.insert(item_type1val);
13447 opened_types_.insert(item_type1compound);
13448 opened_types_.insert(field_types[i]);
13449
13450 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
13451 dbtypes[i]=MAP_VL_STRING_MAP_STRING_INT;
13452 hid_t item_type0;
13453 hsize_t shape01=shape[0];
13454 hid_t item_type1key;
13455 item_type1key=sha1_type_;
13456 hid_t item_type1val;
13457 hsize_t shape02=shape[2];
13458 hid_t item_type2key;
13459 item_type2key=CreateFLStrType(shape[3]);
13460 hid_t item_type2val;
13461 item_type2val=H5T_NATIVE_INT;
13462 hid_t item_type2valcompound;
13463 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(int));
13464 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13465 H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
13466 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13467 hid_t item_type1compound;
13468 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+sizeof(int))*shape[2]));
13469 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13470 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13471 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13472 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
13473 field_types[i]=item_type0;
13474 opened_types_.insert(item_type2valcompound);
13475 opened_types_.insert(item_type1val);
13476 opened_types_.insert(item_type1compound);
13477 opened_types_.insert(field_types[i]);
13478
13479 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
13480 dbtypes[i]=MAP_VL_STRING_VL_MAP_STRING_INT;
13481 hid_t item_type0;
13482 hsize_t shape01=shape[0];
13483 hid_t item_type1key;
13484 item_type1key=sha1_type_;
13485 hid_t item_type1val;
13486 hid_t item_type2key;
13487 item_type2key=sha1_type_;
13488 hid_t item_type2val;
13489 item_type2val=H5T_NATIVE_INT;
13490 hid_t item_type2valcompound;
13491 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13492 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13493 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13494 item_type1val=sha1_type_;
13495 if(vldts_.count(VL_MAP_STRING_INT)==0){
13496 vldts_[VL_MAP_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13497 opened_types_.insert(vldts_[VL_MAP_STRING_INT]);
13498
13499 }
13500 hid_t item_type1compound;
13501 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13502 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13503 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13504 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13505 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
13506 field_types[i]=item_type0;
13507 opened_types_.insert(item_type2valcompound);
13508 opened_types_.insert(item_type1val);
13509 opened_types_.insert(item_type1compound);
13510 opened_types_.insert(field_types[i]);
13511
13512 }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
13513 dbtypes[i]=MAP_VL_STRING_MAP_VL_STRING_INT;
13514 hid_t item_type0;
13515 hsize_t shape01=shape[0];
13516 hid_t item_type1key;
13517 item_type1key=sha1_type_;
13518 hid_t item_type1val;
13519 hsize_t shape02=shape[2];
13520 hid_t item_type2key;
13521 item_type2key=sha1_type_;
13522 hid_t item_type2val;
13523 item_type2val=H5T_NATIVE_INT;
13524 hid_t item_type2valcompound;
13525 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13526 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13527 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13528 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13529 hid_t item_type1compound;
13530 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]));
13531 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13532 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13533 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13534 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
13535 field_types[i]=item_type0;
13536 opened_types_.insert(item_type2valcompound);
13537 opened_types_.insert(item_type1val);
13538 opened_types_.insert(item_type1compound);
13539 opened_types_.insert(field_types[i]);
13540
13541 }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
13542 dbtypes[i]=MAP_VL_STRING_VL_MAP_VL_STRING_INT;
13543 hid_t item_type0;
13544 hsize_t shape01=shape[0];
13545 hid_t item_type1key;
13546 item_type1key=sha1_type_;
13547 hid_t item_type1val;
13548 hid_t item_type2key;
13549 item_type2key=sha1_type_;
13550 hid_t item_type2val;
13551 item_type2val=H5T_NATIVE_INT;
13552 hid_t item_type2valcompound;
13553 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13554 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13555 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13556 item_type1val=sha1_type_;
13557 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13558 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13559 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13560
13561 }
13562 hid_t item_type1compound;
13563 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13564 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13565 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13566 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13567 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
13568 field_types[i]=item_type0;
13569 opened_types_.insert(item_type2valcompound);
13570 opened_types_.insert(item_type1val);
13571 opened_types_.insert(item_type1compound);
13572 opened_types_.insert(field_types[i]);
13573
13574 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]>=1){
13575 dbtypes[i]=VL_MAP_STRING_MAP_STRING_INT;
13576 hid_t item_type0;
13577 hid_t item_type1key;
13578 item_type1key=sha1_type_;
13579 hid_t item_type1val;
13580 hsize_t shape02=shape[2];
13581 hid_t item_type2key;
13582 item_type2key=sha1_type_;
13583 hid_t item_type2val;
13584 item_type2val=H5T_NATIVE_INT;
13585 hid_t item_type2valcompound;
13586 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13587 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13588 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13589 item_type1val=sha1_type_;
13590 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13591 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13592 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13593
13594 }
13595 hid_t item_type1compound;
13596 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13597 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13598 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13599 item_type0=sha1_type_;
13600 if(vldts_.count(VL_MAP_STRING_MAP_STRING_INT)==0){
13601 vldts_[VL_MAP_STRING_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13602 opened_types_.insert(vldts_[VL_MAP_STRING_MAP_STRING_INT]);
13603
13604 }
13605 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13606 field_types[i]=sha1_type_;
13607
13608 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
13609 dbtypes[i]=VL_MAP_VL_STRING_MAP_STRING_INT;
13610 hid_t item_type0;
13611 hid_t item_type1key;
13612 item_type1key=sha1_type_;
13613 hid_t item_type1val;
13614 hsize_t shape02=shape[2];
13615 hid_t item_type2key;
13616 item_type2key=sha1_type_;
13617 hid_t item_type2val;
13618 item_type2val=H5T_NATIVE_INT;
13619 hid_t item_type2valcompound;
13620 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13621 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13622 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13623 item_type1val=sha1_type_;
13624 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13625 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13626 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13627
13628 }
13629 hid_t item_type1compound;
13630 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13631 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13632 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13633 item_type0=sha1_type_;
13634 if(vldts_.count(VL_MAP_VL_STRING_MAP_STRING_INT)==0){
13635 vldts_[VL_MAP_VL_STRING_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13636 opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_STRING_INT]);
13637
13638 }
13639 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13640 field_types[i]=sha1_type_;
13641
13642 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
13643 dbtypes[i]=VL_MAP_STRING_VL_MAP_STRING_INT;
13644 hid_t item_type0;
13645 hid_t item_type1key;
13646 item_type1key=sha1_type_;
13647 hid_t item_type1val;
13648 hid_t item_type2key;
13649 item_type2key=sha1_type_;
13650 hid_t item_type2val;
13651 item_type2val=H5T_NATIVE_INT;
13652 hid_t item_type2valcompound;
13653 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13654 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13655 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13656 item_type1val=sha1_type_;
13657 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13658 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13659 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13660
13661 }
13662 hid_t item_type1compound;
13663 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13664 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13665 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13666 item_type0=sha1_type_;
13667 if(vldts_.count(VL_MAP_STRING_VL_MAP_STRING_INT)==0){
13668 vldts_[VL_MAP_STRING_VL_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13669 opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_STRING_INT]);
13670
13671 }
13672 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13673 field_types[i]=sha1_type_;
13674
13675 }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
13676 dbtypes[i]=VL_MAP_STRING_MAP_VL_STRING_INT;
13677 hid_t item_type0;
13678 hid_t item_type1key;
13679 item_type1key=sha1_type_;
13680 hid_t item_type1val;
13681 hsize_t shape02=shape[2];
13682 hid_t item_type2key;
13683 item_type2key=sha1_type_;
13684 hid_t item_type2val;
13685 item_type2val=H5T_NATIVE_INT;
13686 hid_t item_type2valcompound;
13687 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13688 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13689 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13690 item_type1val=sha1_type_;
13691 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13692 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13693 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13694
13695 }
13696 hid_t item_type1compound;
13697 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13698 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13699 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13700 item_type0=sha1_type_;
13701 if(vldts_.count(VL_MAP_STRING_MAP_VL_STRING_INT)==0){
13702 vldts_[VL_MAP_STRING_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13703 opened_types_.insert(vldts_[VL_MAP_STRING_MAP_VL_STRING_INT]);
13704
13705 }
13706 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13707 field_types[i]=sha1_type_;
13708
13709 }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
13710 dbtypes[i]=VL_MAP_STRING_VL_MAP_VL_STRING_INT;
13711 hid_t item_type0;
13712 hid_t item_type1key;
13713 item_type1key=sha1_type_;
13714 hid_t item_type1val;
13715 hid_t item_type2key;
13716 item_type2key=sha1_type_;
13717 hid_t item_type2val;
13718 item_type2val=H5T_NATIVE_INT;
13719 hid_t item_type2valcompound;
13720 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13721 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13722 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13723 item_type1val=sha1_type_;
13724 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13725 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13726 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13727
13728 }
13729 hid_t item_type1compound;
13730 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13731 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13732 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13733 item_type0=sha1_type_;
13734 if(vldts_.count(VL_MAP_STRING_VL_MAP_VL_STRING_INT)==0){
13735 vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13736 opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_INT]);
13737
13738 }
13739 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13740 field_types[i]=sha1_type_;
13741
13742 }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
13743 dbtypes[i]=VL_MAP_VL_STRING_MAP_VL_STRING_INT;
13744 hid_t item_type0;
13745 hid_t item_type1key;
13746 item_type1key=sha1_type_;
13747 hid_t item_type1val;
13748 hsize_t shape02=shape[2];
13749 hid_t item_type2key;
13750 item_type2key=sha1_type_;
13751 hid_t item_type2val;
13752 item_type2val=H5T_NATIVE_INT;
13753 hid_t item_type2valcompound;
13754 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13755 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13756 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13757 item_type1val=sha1_type_;
13758 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13759 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13760 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13761
13762 }
13763 hid_t item_type1compound;
13764 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13765 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13766 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13767 item_type0=sha1_type_;
13768 if(vldts_.count(VL_MAP_VL_STRING_MAP_VL_STRING_INT)==0){
13769 vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13770 opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_INT]);
13771
13772 }
13773 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13774 field_types[i]=sha1_type_;
13775
13776 }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
13777 dbtypes[i]=VL_MAP_VL_STRING_VL_MAP_STRING_INT;
13778 hid_t item_type0;
13779 hid_t item_type1key;
13780 item_type1key=sha1_type_;
13781 hid_t item_type1val;
13782 hid_t item_type2key;
13783 item_type2key=sha1_type_;
13784 hid_t item_type2val;
13785 item_type2val=H5T_NATIVE_INT;
13786 hid_t item_type2valcompound;
13787 item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13788 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13789 H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13790 item_type1val=sha1_type_;
13791 if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13792 vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13793 opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13794
13795 }
13796 hid_t item_type1compound;
13797 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13798 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13799 H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13800 item_type0=sha1_type_;
13801 if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_STRING_INT)==0){
13802 vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13803 opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_INT]);
13804
13805 }
13806 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13807 field_types[i]=sha1_type_;
13808
13809 }else{
13810 dbtypes[i]=MAP_STRING_MAP_STRING_INT;
13811 hid_t item_type0;
13812 hsize_t shape01=shape[0];
13813 hid_t item_type1key;
13814 item_type1key=CreateFLStrType(shape[1]);
13815 hid_t item_type1val;
13816 hsize_t shape02=shape[2];
13817 hid_t item_type2key;
13818 item_type2key=CreateFLStrType(shape[3]);
13819 hid_t item_type2val;
13820 item_type2val=H5T_NATIVE_INT;
13821 hid_t item_type2valcompound;
13822 item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(int));
13823 H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13824 H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
13825 item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13826 hid_t item_type1compound;
13827 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+sizeof(int))*shape[2]));
13828 H5Tinsert(item_type1compound, "key", 0, item_type1key);
13829 H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13830 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13831 dst_sizes[i]=((shape[1]+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
13832 field_types[i]=item_type0;
13833 opened_types_.insert(item_type2valcompound);
13834 opened_types_.insert(item_type1val);
13835 opened_types_.insert(item_type1compound);
13836 opened_types_.insert(field_types[i]);
13837
13838 }
13839
13840 }else if(valtype==typeid(std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>)){
13841 shape=shapes[i];
13842 if(shape.empty()||shape[0]<1&&shape[5]<1&&shape[6]<1){
13843 dbtypes[i]=VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE;
13844 hid_t item_type0;
13845 hid_t item_type1elem;
13846 hid_t item_type2first;
13847 hid_t item_type3first;
13848 item_type3first=H5T_NATIVE_DOUBLE;
13849 hid_t item_type3second;
13850 item_type3second=H5T_NATIVE_DOUBLE;
13851 hid_t item_type3firstcompound;
13852 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13853 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13854 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13855 hid_t item_type2second;
13856 hid_t item_type3key;
13857 item_type3key=sha1_type_;
13858 hid_t item_type3val;
13859 item_type3val=H5T_NATIVE_DOUBLE;
13860 hid_t item_type3secondcompound;
13861 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13862 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13863 H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13864 item_type2second=sha1_type_;
13865 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
13866 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
13867 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
13868
13869 }
13870 hid_t item_type2elemcompound;
13871 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
13872 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13873 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13874 item_type0=sha1_type_;
13875 if(vldts_.count(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE)==0){
13876 vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
13877 opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE]);
13878
13879 }
13880 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13881 field_types[i]=sha1_type_;
13882
13883 }else if(shape[0]>=1&&shape[5]>=1&&shape[6]<1){
13884 dbtypes[i]=VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE;
13885 hid_t item_type0;
13886 hsize_t shape01=shape[0];
13887 hid_t item_type1elem;
13888 hid_t item_type2first;
13889 hid_t item_type3first;
13890 item_type3first=H5T_NATIVE_DOUBLE;
13891 hid_t item_type3second;
13892 item_type3second=H5T_NATIVE_DOUBLE;
13893 hid_t item_type3firstcompound;
13894 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13895 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13896 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13897 hid_t item_type2second;
13898 hsize_t shape03=shape[5];
13899 hid_t item_type3key;
13900 item_type3key=sha1_type_;
13901 hid_t item_type3val;
13902 item_type3val=H5T_NATIVE_DOUBLE;
13903 hid_t item_type3secondcompound;
13904 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13905 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13906 H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13907 item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
13908 hid_t item_type2elemcompound;
13909 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]));
13910 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13911 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13912 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
13913 dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]))))*shape[0]);
13914 field_types[i]=item_type0;
13915 opened_types_.insert(item_type3firstcompound);
13916 opened_types_.insert(item_type3secondcompound);
13917 opened_types_.insert(item_type2second);
13918 opened_types_.insert(item_type2elemcompound);
13919 opened_types_.insert(field_types[i]);
13920
13921 }else if(shape[0]>=1&&shape[5]<1&&shape[6]>=1){
13922 dbtypes[i]=VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE;
13923 hid_t item_type0;
13924 hsize_t shape01=shape[0];
13925 hid_t item_type1elem;
13926 hid_t item_type2first;
13927 hid_t item_type3first;
13928 item_type3first=H5T_NATIVE_DOUBLE;
13929 hid_t item_type3second;
13930 item_type3second=H5T_NATIVE_DOUBLE;
13931 hid_t item_type3firstcompound;
13932 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13933 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13934 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13935 hid_t item_type2second;
13936 hid_t item_type3key;
13937 item_type3key=sha1_type_;
13938 hid_t item_type3val;
13939 item_type3val=H5T_NATIVE_DOUBLE;
13940 hid_t item_type3secondcompound;
13941 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13942 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13943 H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13944 item_type2second=sha1_type_;
13945 if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
13946 vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
13947 opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
13948
13949 }
13950 hid_t item_type2elemcompound;
13951 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
13952 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13953 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13954 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
13955 dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
13956 field_types[i]=item_type0;
13957 opened_types_.insert(item_type3firstcompound);
13958 opened_types_.insert(item_type3secondcompound);
13959 opened_types_.insert(item_type2second);
13960 opened_types_.insert(item_type2elemcompound);
13961 opened_types_.insert(field_types[i]);
13962
13963 }else if(shape[0]>=1&&shape[5]<1&&shape[6]<1){
13964 dbtypes[i]=VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE;
13965 hid_t item_type0;
13966 hsize_t shape01=shape[0];
13967 hid_t item_type1elem;
13968 hid_t item_type2first;
13969 hid_t item_type3first;
13970 item_type3first=H5T_NATIVE_DOUBLE;
13971 hid_t item_type3second;
13972 item_type3second=H5T_NATIVE_DOUBLE;
13973 hid_t item_type3firstcompound;
13974 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13975 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13976 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13977 hid_t item_type2second;
13978 hid_t item_type3key;
13979 item_type3key=sha1_type_;
13980 hid_t item_type3val;
13981 item_type3val=H5T_NATIVE_DOUBLE;
13982 hid_t item_type3secondcompound;
13983 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13984 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13985 H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13986 item_type2second=sha1_type_;
13987 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
13988 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
13989 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
13990
13991 }
13992 hid_t item_type2elemcompound;
13993 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
13994 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13995 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13996 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
13997 dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
13998 field_types[i]=item_type0;
13999 opened_types_.insert(item_type3firstcompound);
14000 opened_types_.insert(item_type3secondcompound);
14001 opened_types_.insert(item_type2second);
14002 opened_types_.insert(item_type2elemcompound);
14003 opened_types_.insert(field_types[i]);
14004
14005 }else if(shape[0]<1&&shape[5]>=1&&shape[6]>=1){
14006 dbtypes[i]=VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE;
14007 hid_t item_type0;
14008 hid_t item_type1elem;
14009 hid_t item_type2first;
14010 hid_t item_type3first;
14011 item_type3first=H5T_NATIVE_DOUBLE;
14012 hid_t item_type3second;
14013 item_type3second=H5T_NATIVE_DOUBLE;
14014 hid_t item_type3firstcompound;
14015 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14016 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14017 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14018 hid_t item_type2second;
14019 hsize_t shape03=shape[5];
14020 hid_t item_type3key;
14021 item_type3key=sha1_type_;
14022 hid_t item_type3val;
14023 item_type3val=H5T_NATIVE_DOUBLE;
14024 hid_t item_type3secondcompound;
14025 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14026 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14027 H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
14028 item_type2second=sha1_type_;
14029 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14030 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
14031 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14032
14033 }
14034 hid_t item_type2elemcompound;
14035 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14036 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14037 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14038 item_type0=sha1_type_;
14039 if(vldts_.count(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE)==0){
14040 vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
14041 opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE]);
14042
14043 }
14044 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14045 field_types[i]=sha1_type_;
14046
14047 }else if(shape[0]<1&&shape[5]>=1&&shape[6]<1){
14048 dbtypes[i]=VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE;
14049 hid_t item_type0;
14050 hid_t item_type1elem;
14051 hid_t item_type2first;
14052 hid_t item_type3first;
14053 item_type3first=H5T_NATIVE_DOUBLE;
14054 hid_t item_type3second;
14055 item_type3second=H5T_NATIVE_DOUBLE;
14056 hid_t item_type3firstcompound;
14057 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14058 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14059 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14060 hid_t item_type2second;
14061 hsize_t shape03=shape[5];
14062 hid_t item_type3key;
14063 item_type3key=sha1_type_;
14064 hid_t item_type3val;
14065 item_type3val=H5T_NATIVE_DOUBLE;
14066 hid_t item_type3secondcompound;
14067 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14068 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14069 H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
14070 item_type2second=sha1_type_;
14071 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14072 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
14073 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14074
14075 }
14076 hid_t item_type2elemcompound;
14077 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14078 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14079 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14080 item_type0=sha1_type_;
14081 if(vldts_.count(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE)==0){
14082 vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
14083 opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE]);
14084
14085 }
14086 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14087 field_types[i]=sha1_type_;
14088
14089 }else if(shape[0]<1&&shape[5]<1&&shape[6]>=1){
14090 dbtypes[i]=VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE;
14091 hid_t item_type0;
14092 hid_t item_type1elem;
14093 hid_t item_type2first;
14094 hid_t item_type3first;
14095 item_type3first=H5T_NATIVE_DOUBLE;
14096 hid_t item_type3second;
14097 item_type3second=H5T_NATIVE_DOUBLE;
14098 hid_t item_type3firstcompound;
14099 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14100 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14101 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14102 hid_t item_type2second;
14103 hid_t item_type3key;
14104 item_type3key=sha1_type_;
14105 hid_t item_type3val;
14106 item_type3val=H5T_NATIVE_DOUBLE;
14107 hid_t item_type3secondcompound;
14108 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14109 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14110 H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
14111 item_type2second=sha1_type_;
14112 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14113 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
14114 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14115
14116 }
14117 hid_t item_type2elemcompound;
14118 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14119 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14120 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14121 item_type0=sha1_type_;
14122 if(vldts_.count(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE)==0){
14123 vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
14124 opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE]);
14125
14126 }
14127 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14128 field_types[i]=sha1_type_;
14129
14130 }else{
14131 dbtypes[i]=VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE;
14132 hid_t item_type0;
14133 hsize_t shape01=shape[0];
14134 hid_t item_type1elem;
14135 hid_t item_type2first;
14136 hid_t item_type3first;
14137 item_type3first=H5T_NATIVE_DOUBLE;
14138 hid_t item_type3second;
14139 item_type3second=H5T_NATIVE_DOUBLE;
14140 hid_t item_type3firstcompound;
14141 item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14142 H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14143 H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14144 hid_t item_type2second;
14145 hsize_t shape03=shape[5];
14146 hid_t item_type3key;
14147 item_type3key=CreateFLStrType(shape[6]);
14148 hid_t item_type3val;
14149 item_type3val=H5T_NATIVE_DOUBLE;
14150 hid_t item_type3secondcompound;
14151 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+sizeof(double));
14152 H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14153 H5Tinsert(item_type3secondcompound, "val", 0+shape[6], item_type3val);
14154 item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
14155 hid_t item_type2elemcompound;
14156 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5]));
14157 H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14158 H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14159 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14160 dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5]))))*shape[0]);
14161 field_types[i]=item_type0;
14162 opened_types_.insert(item_type3firstcompound);
14163 opened_types_.insert(item_type3secondcompound);
14164 opened_types_.insert(item_type2second);
14165 opened_types_.insert(item_type2elemcompound);
14166 opened_types_.insert(field_types[i]);
14167
14168 }
14169
14170 }else if(valtype==typeid(std::pair<int, std::pair<std::string, std::string>>)){
14171 shape=shapes[i];
14172 if(shape.empty()||shape[3]<1&&shape[4]<1){
14173 dbtypes[i]=PAIR_INT_PAIR_VL_STRING_VL_STRING;
14174 hid_t item_type0;
14175 hid_t item_type1first;
14176 item_type1first=H5T_NATIVE_INT;
14177 hid_t item_type1second;
14178 hid_t item_type2first;
14179 item_type2first=sha1_type_;
14180 hid_t item_type2second;
14181 item_type2second=sha1_type_;
14182 hid_t item_type2secondcompound;
14183 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14184 H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14185 H5Tinsert(item_type2secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14186 hid_t item_type1compound;
14187 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14188 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14189 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14190 dst_sizes[i]=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
14191 field_types[i]=item_type1compound;
14192 opened_types_.insert(item_type2secondcompound);
14193 opened_types_.insert(field_types[i]);
14194
14195 }else if(shape[3]<1&&shape[4]>=1){
14196 dbtypes[i]=PAIR_INT_PAIR_VL_STRING_STRING;
14197 hid_t item_type0;
14198 hid_t item_type1first;
14199 item_type1first=H5T_NATIVE_INT;
14200 hid_t item_type1second;
14201 hid_t item_type2first;
14202 item_type2first=sha1_type_;
14203 hid_t item_type2second;
14204 item_type2second=CreateFLStrType(shape[4]);
14205 hid_t item_type2secondcompound;
14206 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[4]);
14207 H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14208 H5Tinsert(item_type2secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14209 hid_t item_type1compound;
14210 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[4])));
14211 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14212 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14213 dst_sizes[i]=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[4]))));
14214 field_types[i]=item_type1compound;
14215 opened_types_.insert(item_type2secondcompound);
14216 opened_types_.insert(field_types[i]);
14217
14218 }else if(shape[3]>=1&&shape[4]<1){
14219 dbtypes[i]=PAIR_INT_PAIR_STRING_VL_STRING;
14220 hid_t item_type0;
14221 hid_t item_type1first;
14222 item_type1first=H5T_NATIVE_INT;
14223 hid_t item_type1second;
14224 hid_t item_type2first;
14225 item_type2first=CreateFLStrType(shape[3]);
14226 hid_t item_type2second;
14227 item_type2second=sha1_type_;
14228 hid_t item_type2secondcompound;
14229 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, shape[3]+CYCLUS_SHA1_SIZE);
14230 H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14231 H5Tinsert(item_type2secondcompound, "second", 0+shape[3], item_type2second);
14232 hid_t item_type1compound;
14233 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[3]+CYCLUS_SHA1_SIZE)));
14234 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14235 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14236 dst_sizes[i]=((sizeof(int)+((shape[3]+CYCLUS_SHA1_SIZE))));
14237 field_types[i]=item_type1compound;
14238 opened_types_.insert(item_type2secondcompound);
14239 opened_types_.insert(field_types[i]);
14240
14241 }else{
14242 dbtypes[i]=PAIR_INT_PAIR_STRING_STRING;
14243 hid_t item_type0;
14244 hid_t item_type1first;
14245 item_type1first=H5T_NATIVE_INT;
14246 hid_t item_type1second;
14247 hid_t item_type2first;
14248 item_type2first=CreateFLStrType(shape[3]);
14249 hid_t item_type2second;
14250 item_type2second=CreateFLStrType(shape[4]);
14251 hid_t item_type2secondcompound;
14252 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, shape[3]+shape[4]);
14253 H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14254 H5Tinsert(item_type2secondcompound, "second", 0+shape[3], item_type2second);
14255 hid_t item_type1compound;
14256 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[3]+shape[4])));
14257 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14258 H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14259 dst_sizes[i]=((sizeof(int)+((shape[3]+shape[4]))));
14260 field_types[i]=item_type1compound;
14261 opened_types_.insert(item_type2secondcompound);
14262 opened_types_.insert(field_types[i]);
14263
14264 }
14265
14266 }else if(valtype==typeid(std::pair<double, double>)){
14267 shape=shapes[i];
14268 dbtypes[i]=PAIR_DOUBLE_DOUBLE;
14269 hid_t item_type0;
14270 hid_t item_type1first;
14271 item_type1first=H5T_NATIVE_DOUBLE;
14272 hid_t item_type1second;
14273 item_type1second=H5T_NATIVE_DOUBLE;
14274 hid_t item_type1compound;
14275 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14276 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14277 H5Tinsert(item_type1compound, "second", 0+sizeof(double), item_type1second);
14278 dst_sizes[i]=((sizeof(double)+sizeof(double)));
14279 field_types[i]=item_type1compound;
14280 opened_types_.insert(field_types[i]);
14281
14282 }else if(valtype==typeid(std::pair<std::pair<double, double>, std::map<std::string, double>>)){
14283 shape=shapes[i];
14284 if(shape.empty()||shape[4]<1&&shape[5]<1){
14285 dbtypes[i]=PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE;
14286 hid_t item_type0;
14287 hid_t item_type1first;
14288 hid_t item_type2first;
14289 item_type2first=H5T_NATIVE_DOUBLE;
14290 hid_t item_type2second;
14291 item_type2second=H5T_NATIVE_DOUBLE;
14292 hid_t item_type2firstcompound;
14293 item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14294 H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14295 H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14296 hid_t item_type1second;
14297 hid_t item_type2key;
14298 item_type2key=sha1_type_;
14299 hid_t item_type2val;
14300 item_type2val=H5T_NATIVE_DOUBLE;
14301 hid_t item_type2secondcompound;
14302 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14303 H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14304 H5Tinsert(item_type2secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
14305 item_type1second=sha1_type_;
14306 if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14307 vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2secondcompound);
14308 opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14309
14310 }
14311 hid_t item_type1compound;
14312 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14313 H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14314 H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14315 dst_sizes[i]=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
14316 field_types[i]=item_type1compound;
14317 opened_types_.insert(item_type2firstcompound);
14318 opened_types_.insert(item_type2secondcompound);
14319 opened_types_.insert(item_type1second);
14320 opened_types_.insert(field_types[i]);
14321
14322 }else if(shape[4]>=1&&shape[5]<1){
14323 dbtypes[i]=PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE;
14324 hid_t item_type0;
14325 hid_t item_type1first;
14326 hid_t item_type2first;
14327 item_type2first=H5T_NATIVE_DOUBLE;
14328 hid_t item_type2second;
14329 item_type2second=H5T_NATIVE_DOUBLE;
14330 hid_t item_type2firstcompound;
14331 item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14332 H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14333 H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14334 hid_t item_type1second;
14335 hsize_t shape02=shape[4];
14336 hid_t item_type2key;
14337 item_type2key=sha1_type_;
14338 hid_t item_type2val;
14339 item_type2val=H5T_NATIVE_DOUBLE;
14340 hid_t item_type2secondcompound;
14341 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14342 H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14343 H5Tinsert(item_type2secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
14344 item_type1second=H5Tarray_create2(item_type2secondcompound, 1, &shape02);
14345 hid_t item_type1compound;
14346 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4]));
14347 H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14348 H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14349 dst_sizes[i]=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4])));
14350 field_types[i]=item_type1compound;
14351 opened_types_.insert(item_type2firstcompound);
14352 opened_types_.insert(item_type2secondcompound);
14353 opened_types_.insert(item_type1second);
14354 opened_types_.insert(field_types[i]);
14355
14356 }else if(shape[4]<1&&shape[5]>=1){
14357 dbtypes[i]=PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE;
14358 hid_t item_type0;
14359 hid_t item_type1first;
14360 hid_t item_type2first;
14361 item_type2first=H5T_NATIVE_DOUBLE;
14362 hid_t item_type2second;
14363 item_type2second=H5T_NATIVE_DOUBLE;
14364 hid_t item_type2firstcompound;
14365 item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14366 H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14367 H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14368 hid_t item_type1second;
14369 hid_t item_type2key;
14370 item_type2key=sha1_type_;
14371 hid_t item_type2val;
14372 item_type2val=H5T_NATIVE_DOUBLE;
14373 hid_t item_type2secondcompound;
14374 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14375 H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14376 H5Tinsert(item_type2secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
14377 item_type1second=sha1_type_;
14378 if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
14379 vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2secondcompound);
14380 opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
14381
14382 }
14383 hid_t item_type1compound;
14384 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14385 H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14386 H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14387 dst_sizes[i]=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
14388 field_types[i]=item_type1compound;
14389 opened_types_.insert(item_type2firstcompound);
14390 opened_types_.insert(item_type2secondcompound);
14391 opened_types_.insert(item_type1second);
14392 opened_types_.insert(field_types[i]);
14393
14394 }else{
14395 dbtypes[i]=PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE;
14396 hid_t item_type0;
14397 hid_t item_type1first;
14398 hid_t item_type2first;
14399 item_type2first=H5T_NATIVE_DOUBLE;
14400 hid_t item_type2second;
14401 item_type2second=H5T_NATIVE_DOUBLE;
14402 hid_t item_type2firstcompound;
14403 item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14404 H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14405 H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14406 hid_t item_type1second;
14407 hsize_t shape02=shape[4];
14408 hid_t item_type2key;
14409 item_type2key=CreateFLStrType(shape[5]);
14410 hid_t item_type2val;
14411 item_type2val=H5T_NATIVE_DOUBLE;
14412 hid_t item_type2secondcompound;
14413 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, shape[5]+sizeof(double));
14414 H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14415 H5Tinsert(item_type2secondcompound, "val", 0+shape[5], item_type2val);
14416 item_type1second=H5Tarray_create2(item_type2secondcompound, 1, &shape02);
14417 hid_t item_type1compound;
14418 item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((shape[5]+sizeof(double))*shape[4]));
14419 H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14420 H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14421 dst_sizes[i]=((((sizeof(double)+sizeof(double)))+((shape[5]+sizeof(double))*shape[4])));
14422 field_types[i]=item_type1compound;
14423 opened_types_.insert(item_type2firstcompound);
14424 opened_types_.insert(item_type2secondcompound);
14425 opened_types_.insert(item_type1second);
14426 opened_types_.insert(field_types[i]);
14427
14428 }
14429
14430 }else if(valtype==typeid(std::pair<double, std::map<int, double>>)){
14431 shape=shapes[i];
14432 if(shape.empty()||shape[2]<1){
14433 dbtypes[i]=PAIR_DOUBLE_VL_MAP_INT_DOUBLE;
14434 hid_t item_type0;
14435 hid_t item_type1first;
14436 item_type1first=H5T_NATIVE_DOUBLE;
14437 hid_t item_type1second;
14438 hid_t item_type2key;
14439 item_type2key=H5T_NATIVE_INT;
14440 hid_t item_type2val;
14441 item_type2val=H5T_NATIVE_DOUBLE;
14442 hid_t item_type2secondcompound;
14443 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
14444 H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14445 H5Tinsert(item_type2secondcompound, "val", 0+sizeof(int), item_type2val);
14446 item_type1second=sha1_type_;
14447 if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
14448 vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2secondcompound);
14449 opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
14450
14451 }
14452 hid_t item_type1compound;
14453 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
14454 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14455 H5Tinsert(item_type1compound, "second", 0+sizeof(double), item_type1second);
14456 dst_sizes[i]=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
14457 field_types[i]=item_type1compound;
14458 opened_types_.insert(item_type2secondcompound);
14459 opened_types_.insert(item_type1second);
14460 opened_types_.insert(field_types[i]);
14461
14462 }else{
14463 dbtypes[i]=PAIR_DOUBLE_MAP_INT_DOUBLE;
14464 hid_t item_type0;
14465 hid_t item_type1first;
14466 item_type1first=H5T_NATIVE_DOUBLE;
14467 hid_t item_type1second;
14468 hsize_t shape02=shape[2];
14469 hid_t item_type2key;
14470 item_type2key=H5T_NATIVE_INT;
14471 hid_t item_type2val;
14472 item_type2val=H5T_NATIVE_DOUBLE;
14473 hid_t item_type2secondcompound;
14474 item_type2secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
14475 H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14476 H5Tinsert(item_type2secondcompound, "val", 0+sizeof(int), item_type2val);
14477 item_type1second=H5Tarray_create2(item_type2secondcompound, 1, &shape02);
14478 hid_t item_type1compound;
14479 item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(double)+((sizeof(int)+sizeof(double))*shape[2]));
14480 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14481 H5Tinsert(item_type1compound, "second", 0+sizeof(double), item_type1second);
14482 dst_sizes[i]=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[2])));
14483 field_types[i]=item_type1compound;
14484 opened_types_.insert(item_type2secondcompound);
14485 opened_types_.insert(item_type1second);
14486 opened_types_.insert(field_types[i]);
14487
14488 }
14489
14490 }else if(valtype==typeid(std::vector<std::pair<int, std::pair<std::string, std::string>>>)){
14491 shape=shapes[i];
14492 if(shape.empty()||shape[0]<1&&shape[4]<1&&shape[5]<1){
14493 dbtypes[i]=VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
14494 hid_t item_type0;
14495 hid_t item_type1elem;
14496 hid_t item_type2first;
14497 item_type2first=H5T_NATIVE_INT;
14498 hid_t item_type2second;
14499 hid_t item_type3first;
14500 item_type3first=sha1_type_;
14501 hid_t item_type3second;
14502 item_type3second=sha1_type_;
14503 hid_t item_type3secondcompound;
14504 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14505 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14506 H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14507 hid_t item_type2elemcompound;
14508 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14509 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14510 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14511 item_type0=sha1_type_;
14512 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
14513 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type2elemcompound);
14514 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
14515
14516 }
14517 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14518 field_types[i]=sha1_type_;
14519
14520 }else if(shape[0]>=1&&shape[4]<1&&shape[5]>=1){
14521 dbtypes[i]=VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
14522 hid_t item_type0;
14523 hsize_t shape01=shape[0];
14524 hid_t item_type1elem;
14525 hid_t item_type2first;
14526 item_type2first=H5T_NATIVE_INT;
14527 hid_t item_type2second;
14528 hid_t item_type3first;
14529 item_type3first=sha1_type_;
14530 hid_t item_type3second;
14531 item_type3second=CreateFLStrType(shape[5]);
14532 hid_t item_type3secondcompound;
14533 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[5]);
14534 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14535 H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14536 hid_t item_type2elemcompound;
14537 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5])));
14538 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14539 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14540 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14541 dst_sizes[i]=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5])))))*shape[0]);
14542 field_types[i]=item_type0;
14543 opened_types_.insert(item_type3secondcompound);
14544 opened_types_.insert(item_type2elemcompound);
14545 opened_types_.insert(field_types[i]);
14546
14547 }else if(shape[0]>=1&&shape[4]>=1&&shape[5]<1){
14548 dbtypes[i]=VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
14549 hid_t item_type0;
14550 hsize_t shape01=shape[0];
14551 hid_t item_type1elem;
14552 hid_t item_type2first;
14553 item_type2first=H5T_NATIVE_INT;
14554 hid_t item_type2second;
14555 hid_t item_type3first;
14556 item_type3first=CreateFLStrType(shape[4]);
14557 hid_t item_type3second;
14558 item_type3second=sha1_type_;
14559 hid_t item_type3secondcompound;
14560 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, shape[4]+CYCLUS_SHA1_SIZE);
14561 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14562 H5Tinsert(item_type3secondcompound, "second", 0+shape[4], item_type3second);
14563 hid_t item_type2elemcompound;
14564 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE)));
14565 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14566 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14567 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14568 dst_sizes[i]=((((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE)))))*shape[0]);
14569 field_types[i]=item_type0;
14570 opened_types_.insert(item_type3secondcompound);
14571 opened_types_.insert(item_type2elemcompound);
14572 opened_types_.insert(field_types[i]);
14573
14574 }else if(shape[0]>=1&&shape[4]<1&&shape[5]<1){
14575 dbtypes[i]=VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING;
14576 hid_t item_type0;
14577 hsize_t shape01=shape[0];
14578 hid_t item_type1elem;
14579 hid_t item_type2first;
14580 item_type2first=H5T_NATIVE_INT;
14581 hid_t item_type2second;
14582 hid_t item_type3first;
14583 item_type3first=sha1_type_;
14584 hid_t item_type3second;
14585 item_type3second=sha1_type_;
14586 hid_t item_type3secondcompound;
14587 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14588 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14589 H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14590 hid_t item_type2elemcompound;
14591 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14592 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14593 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14594 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14595 dst_sizes[i]=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[0]);
14596 field_types[i]=item_type0;
14597 opened_types_.insert(item_type3secondcompound);
14598 opened_types_.insert(item_type2elemcompound);
14599 opened_types_.insert(field_types[i]);
14600
14601 }else if(shape[0]<1&&shape[4]>=1&&shape[5]>=1){
14602 dbtypes[i]=VL_VECTOR_PAIR_INT_PAIR_STRING_STRING;
14603 hid_t item_type0;
14604 hid_t item_type1elem;
14605 hid_t item_type2first;
14606 item_type2first=H5T_NATIVE_INT;
14607 hid_t item_type2second;
14608 hid_t item_type3first;
14609 item_type3first=sha1_type_;
14610 hid_t item_type3second;
14611 item_type3second=sha1_type_;
14612 hid_t item_type3secondcompound;
14613 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14614 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14615 H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14616 hid_t item_type2elemcompound;
14617 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14618 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14619 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14620 item_type0=sha1_type_;
14621 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
14622 vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type2elemcompound);
14623 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
14624
14625 }
14626 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14627 field_types[i]=sha1_type_;
14628
14629 }else if(shape[0]<1&&shape[4]<1&&shape[5]>=1){
14630 dbtypes[i]=VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING;
14631 hid_t item_type0;
14632 hid_t item_type1elem;
14633 hid_t item_type2first;
14634 item_type2first=H5T_NATIVE_INT;
14635 hid_t item_type2second;
14636 hid_t item_type3first;
14637 item_type3first=sha1_type_;
14638 hid_t item_type3second;
14639 item_type3second=sha1_type_;
14640 hid_t item_type3secondcompound;
14641 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14642 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14643 H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14644 hid_t item_type2elemcompound;
14645 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14646 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14647 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14648 item_type0=sha1_type_;
14649 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
14650 vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type2elemcompound);
14651 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
14652
14653 }
14654 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14655 field_types[i]=sha1_type_;
14656
14657 }else if(shape[0]<1&&shape[4]>=1&&shape[5]<1){
14658 dbtypes[i]=VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING;
14659 hid_t item_type0;
14660 hid_t item_type1elem;
14661 hid_t item_type2first;
14662 item_type2first=H5T_NATIVE_INT;
14663 hid_t item_type2second;
14664 hid_t item_type3first;
14665 item_type3first=sha1_type_;
14666 hid_t item_type3second;
14667 item_type3second=sha1_type_;
14668 hid_t item_type3secondcompound;
14669 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14670 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14671 H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14672 hid_t item_type2elemcompound;
14673 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14674 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14675 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14676 item_type0=sha1_type_;
14677 if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
14678 vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type2elemcompound);
14679 opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
14680
14681 }
14682 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14683 field_types[i]=sha1_type_;
14684
14685 }else{
14686 dbtypes[i]=VECTOR_PAIR_INT_PAIR_STRING_STRING;
14687 hid_t item_type0;
14688 hsize_t shape01=shape[0];
14689 hid_t item_type1elem;
14690 hid_t item_type2first;
14691 item_type2first=H5T_NATIVE_INT;
14692 hid_t item_type2second;
14693 hid_t item_type3first;
14694 item_type3first=CreateFLStrType(shape[4]);
14695 hid_t item_type3second;
14696 item_type3second=CreateFLStrType(shape[5]);
14697 hid_t item_type3secondcompound;
14698 item_type3secondcompound=H5Tcreate(H5T_COMPOUND, shape[4]+shape[5]);
14699 H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14700 H5Tinsert(item_type3secondcompound, "second", 0+shape[4], item_type3second);
14701 hid_t item_type2elemcompound;
14702 item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[4]+shape[5])));
14703 H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14704 H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14705 item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14706 dst_sizes[i]=((((sizeof(int)+((shape[4]+shape[5])))))*shape[0]);
14707 field_types[i]=item_type0;
14708 opened_types_.insert(item_type3secondcompound);
14709 opened_types_.insert(item_type2elemcompound);
14710 opened_types_.insert(field_types[i]);
14711
14712 }
14713
14714 }else if(valtype==typeid(std::pair<std::string, std::vector<double>>)){
14715 shape=shapes[i];
14716 if(shape.empty()||shape[1]<1&&shape[2]<1){
14717 dbtypes[i]=PAIR_VL_STRING_VL_VECTOR_DOUBLE;
14718 hid_t item_type0;
14719 hid_t item_type1first;
14720 item_type1first=sha1_type_;
14721 hid_t item_type1second;
14722 hid_t item_type2elem;
14723 item_type2elem=H5T_NATIVE_DOUBLE;
14724 item_type1second=sha1_type_;
14725 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
14726 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
14727 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
14728
14729 }
14730 hid_t item_type1compound;
14731 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
14732 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14733 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
14734 dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
14735 field_types[i]=item_type1compound;
14736 opened_types_.insert(item_type1second);
14737 opened_types_.insert(field_types[i]);
14738
14739 }else if(shape[1]<1&&shape[2]>=1){
14740 dbtypes[i]=PAIR_VL_STRING_VECTOR_DOUBLE;
14741 hid_t item_type0;
14742 hid_t item_type1first;
14743 item_type1first=sha1_type_;
14744 hid_t item_type1second;
14745 hsize_t shape02=shape[2];
14746 hid_t item_type2elem;
14747 item_type2elem=H5T_NATIVE_DOUBLE;
14748 item_type1second=H5Tarray_create2(item_type2elem, 1, &shape02);
14749 hid_t item_type1compound;
14750 item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]));
14751 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14752 H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
14753 dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2])));
14754 field_types[i]=item_type1compound;
14755 opened_types_.insert(item_type1second);
14756 opened_types_.insert(field_types[i]);
14757
14758 }else if(shape[1]>=1&&shape[2]<1){
14759 dbtypes[i]=PAIR_STRING_VL_VECTOR_DOUBLE;
14760 hid_t item_type0;
14761 hid_t item_type1first;
14762 item_type1first=CreateFLStrType(shape[1]);
14763 hid_t item_type1second;
14764 hid_t item_type2elem;
14765 item_type2elem=H5T_NATIVE_DOUBLE;
14766 item_type1second=sha1_type_;
14767 if(vldts_.count(VL_VECTOR_DOUBLE)==0){
14768 vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
14769 opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
14770
14771 }
14772 hid_t item_type1compound;
14773 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
14774 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14775 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
14776 dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE)));
14777 field_types[i]=item_type1compound;
14778 opened_types_.insert(item_type1second);
14779 opened_types_.insert(field_types[i]);
14780
14781 }else{
14782 dbtypes[i]=PAIR_STRING_VECTOR_DOUBLE;
14783 hid_t item_type0;
14784 hid_t item_type1first;
14785 item_type1first=CreateFLStrType(shape[1]);
14786 hid_t item_type1second;
14787 hsize_t shape02=shape[2];
14788 hid_t item_type2elem;
14789 item_type2elem=H5T_NATIVE_DOUBLE;
14790 item_type1second=H5Tarray_create2(item_type2elem, 1, &shape02);
14791 hid_t item_type1compound;
14792 item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double))*shape[2]));
14793 H5Tinsert(item_type1compound, "first", 0, item_type1first);
14794 H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
14795 dst_sizes[i]=((shape[1]+((sizeof(double))*shape[2])));
14796 field_types[i]=item_type1compound;
14797 opened_types_.insert(item_type1second);
14798 opened_types_.insert(field_types[i]);
14799
14800 }
14801
14802 }else if(valtype==typeid(std::map<std::pair<std::string, std::string>, int>)){
14803 shape=shapes[i];
14804 if(shape.empty()||shape[0]<1&&shape[2]<1&&shape[3]<1){
14805 dbtypes[i]=VL_MAP_PAIR_VL_STRING_VL_STRING_INT;
14806 hid_t item_type0;
14807 hid_t item_type1key;
14808 hid_t item_type2first;
14809 item_type2first=sha1_type_;
14810 hid_t item_type2second;
14811 item_type2second=sha1_type_;
14812 hid_t item_type2keycompound;
14813 item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14814 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14815 H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14816 hid_t item_type1val;
14817 item_type1val=H5T_NATIVE_INT;
14818 hid_t item_type1compound;
14819 item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14820 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14821 H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14822 item_type0=sha1_type_;
14823 if(vldts_.count(VL_MAP_PAIR_VL_STRING_VL_STRING_INT)==0){
14824 vldts_[VL_MAP_PAIR_VL_STRING_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
14825 opened_types_.insert(vldts_[VL_MAP_PAIR_VL_STRING_VL_STRING_INT]);
14826
14827 }
14828 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14829 field_types[i]=sha1_type_;
14830
14831 }else if(shape[0]>=1&&shape[2]>=1&&shape[3]<1){
14832 dbtypes[i]=MAP_PAIR_STRING_VL_STRING_INT;
14833 hid_t item_type0;
14834 hsize_t shape01=shape[0];
14835 hid_t item_type1key;
14836 hid_t item_type2first;
14837 item_type2first=CreateFLStrType(shape[2]);
14838 hid_t item_type2second;
14839 item_type2second=sha1_type_;
14840 hid_t item_type2keycompound;
14841 item_type2keycompound=H5Tcreate(H5T_COMPOUND, shape[2]+CYCLUS_SHA1_SIZE);
14842 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14843 H5Tinsert(item_type2keycompound, "second", 0+shape[2], item_type2second);
14844 hid_t item_type1val;
14845 item_type1val=H5T_NATIVE_INT;
14846 hid_t item_type1compound;
14847 item_type1compound=H5Tcreate(H5T_COMPOUND, ((shape[2]+CYCLUS_SHA1_SIZE))+sizeof(int));
14848 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14849 H5Tinsert(item_type1compound, "val", 0+((shape[2]+CYCLUS_SHA1_SIZE)), item_type1val);
14850 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
14851 dst_sizes[i]=((((shape[2]+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
14852 field_types[i]=item_type0;
14853 opened_types_.insert(item_type2keycompound);
14854 opened_types_.insert(item_type1compound);
14855 opened_types_.insert(field_types[i]);
14856
14857 }else if(shape[0]>=1&&shape[2]<1&&shape[3]>=1){
14858 dbtypes[i]=MAP_PAIR_VL_STRING_STRING_INT;
14859 hid_t item_type0;
14860 hsize_t shape01=shape[0];
14861 hid_t item_type1key;
14862 hid_t item_type2first;
14863 item_type2first=sha1_type_;
14864 hid_t item_type2second;
14865 item_type2second=CreateFLStrType(shape[3]);
14866 hid_t item_type2keycompound;
14867 item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[3]);
14868 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14869 H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14870 hid_t item_type1val;
14871 item_type1val=H5T_NATIVE_INT;
14872 hid_t item_type1compound;
14873 item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+shape[3]))+sizeof(int));
14874 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14875 H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+shape[3])), item_type1val);
14876 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
14877 dst_sizes[i]=((((CYCLUS_SHA1_SIZE+shape[3]))+sizeof(int))*shape[0]);
14878 field_types[i]=item_type0;
14879 opened_types_.insert(item_type2keycompound);
14880 opened_types_.insert(item_type1compound);
14881 opened_types_.insert(field_types[i]);
14882
14883 }else if(shape[0]>=1&&shape[2]<1&&shape[3]<1){
14884 dbtypes[i]=MAP_PAIR_VL_STRING_VL_STRING_INT;
14885 hid_t item_type0;
14886 hsize_t shape01=shape[0];
14887 hid_t item_type1key;
14888 hid_t item_type2first;
14889 item_type2first=sha1_type_;
14890 hid_t item_type2second;
14891 item_type2second=sha1_type_;
14892 hid_t item_type2keycompound;
14893 item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14894 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14895 H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14896 hid_t item_type1val;
14897 item_type1val=H5T_NATIVE_INT;
14898 hid_t item_type1compound;
14899 item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14900 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14901 H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14902 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
14903 dst_sizes[i]=((((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
14904 field_types[i]=item_type0;
14905 opened_types_.insert(item_type2keycompound);
14906 opened_types_.insert(item_type1compound);
14907 opened_types_.insert(field_types[i]);
14908
14909 }else if(shape[0]<1&&shape[2]>=1&&shape[3]>=1){
14910 dbtypes[i]=VL_MAP_PAIR_STRING_STRING_INT;
14911 hid_t item_type0;
14912 hid_t item_type1key;
14913 hid_t item_type2first;
14914 item_type2first=sha1_type_;
14915 hid_t item_type2second;
14916 item_type2second=sha1_type_;
14917 hid_t item_type2keycompound;
14918 item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14919 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14920 H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14921 hid_t item_type1val;
14922 item_type1val=H5T_NATIVE_INT;
14923 hid_t item_type1compound;
14924 item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14925 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14926 H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14927 item_type0=sha1_type_;
14928 if(vldts_.count(VL_MAP_PAIR_STRING_STRING_INT)==0){
14929 vldts_[VL_MAP_PAIR_STRING_STRING_INT]=H5Tvlen_create(item_type1compound);
14930 opened_types_.insert(vldts_[VL_MAP_PAIR_STRING_STRING_INT]);
14931
14932 }
14933 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14934 field_types[i]=sha1_type_;
14935
14936 }else if(shape[0]<1&&shape[2]>=1&&shape[3]<1){
14937 dbtypes[i]=VL_MAP_PAIR_STRING_VL_STRING_INT;
14938 hid_t item_type0;
14939 hid_t item_type1key;
14940 hid_t item_type2first;
14941 item_type2first=sha1_type_;
14942 hid_t item_type2second;
14943 item_type2second=sha1_type_;
14944 hid_t item_type2keycompound;
14945 item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14946 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14947 H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14948 hid_t item_type1val;
14949 item_type1val=H5T_NATIVE_INT;
14950 hid_t item_type1compound;
14951 item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14952 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14953 H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14954 item_type0=sha1_type_;
14955 if(vldts_.count(VL_MAP_PAIR_STRING_VL_STRING_INT)==0){
14956 vldts_[VL_MAP_PAIR_STRING_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
14957 opened_types_.insert(vldts_[VL_MAP_PAIR_STRING_VL_STRING_INT]);
14958
14959 }
14960 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14961 field_types[i]=sha1_type_;
14962
14963 }else if(shape[0]<1&&shape[2]<1&&shape[3]>=1){
14964 dbtypes[i]=VL_MAP_PAIR_VL_STRING_STRING_INT;
14965 hid_t item_type0;
14966 hid_t item_type1key;
14967 hid_t item_type2first;
14968 item_type2first=sha1_type_;
14969 hid_t item_type2second;
14970 item_type2second=sha1_type_;
14971 hid_t item_type2keycompound;
14972 item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14973 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14974 H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14975 hid_t item_type1val;
14976 item_type1val=H5T_NATIVE_INT;
14977 hid_t item_type1compound;
14978 item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14979 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14980 H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14981 item_type0=sha1_type_;
14982 if(vldts_.count(VL_MAP_PAIR_VL_STRING_STRING_INT)==0){
14983 vldts_[VL_MAP_PAIR_VL_STRING_STRING_INT]=H5Tvlen_create(item_type1compound);
14984 opened_types_.insert(vldts_[VL_MAP_PAIR_VL_STRING_STRING_INT]);
14985
14986 }
14987 dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14988 field_types[i]=sha1_type_;
14989
14990 }else{
14991 dbtypes[i]=MAP_PAIR_STRING_STRING_INT;
14992 hid_t item_type0;
14993 hsize_t shape01=shape[0];
14994 hid_t item_type1key;
14995 hid_t item_type2first;
14996 item_type2first=CreateFLStrType(shape[2]);
14997 hid_t item_type2second;
14998 item_type2second=CreateFLStrType(shape[3]);
14999 hid_t item_type2keycompound;
15000 item_type2keycompound=H5Tcreate(H5T_COMPOUND, shape[2]+shape[3]);
15001 H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
15002 H5Tinsert(item_type2keycompound, "second", 0+shape[2], item_type2second);
15003 hid_t item_type1val;
15004 item_type1val=H5T_NATIVE_INT;
15005 hid_t item_type1compound;
15006 item_type1compound=H5Tcreate(H5T_COMPOUND, ((shape[2]+shape[3]))+sizeof(int));
15007 H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
15008 H5Tinsert(item_type1compound, "val", 0+((shape[2]+shape[3])), item_type1val);
15009 item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
15010 dst_sizes[i]=((((shape[2]+shape[3]))+sizeof(int))*shape[0]);
15011 field_types[i]=item_type0;
15012 opened_types_.insert(item_type2keycompound);
15013 opened_types_.insert(item_type1compound);
15014 opened_types_.insert(field_types[i]);
15015
15016 }
15017
15018 }else{
15019 throw IOError("the type for column '"+std::string(field_names[i])+"' is not yet supported in HDF5.");
15020 }
15021
15022
15023 dst_size += dst_sizes[i];
15024 }
15025
15026 std::string titlestr = d->title();
15027 const char* title = titlestr.c_str();
15028 int compress = 1;
15029 int chunk_size = 1024;
15030 void* fill_data = NULL;
15031 void* data = NULL;
15032
15033 // Make the table
15034 status = H5TBmake_table(title, file_, title, nvals, 0, dst_size,
15035 field_names, dst_offset, field_types, chunk_size,
15036 fill_data, compress, data);
15037 if (status < 0) {
15038 std::stringstream ss;
15039 ss << "Failed to create HDF5 table:\n" \
15040 << " file " << path_ << "\n" \
15041 << " table " << title << "\n" \
15042 << " chunksize " << chunk_size << "\n" \
15043 << " rowsize " << dst_size << "\n";
15044 for (int i = 0; i < nvals; ++i) {
15045 ss << " #" << i << " " << field_names[i] << "\n" \
15046 << " dbtype: " << dbtypes[i] << "\n" \
15047 << " h5type: " << field_types[i] << "\n" \
15048 << " size: " << dst_sizes[i] << "\n" \
15049 << " offset: " << dst_offset[i] << "\n";
15050 }
15051 throw IOError(ss.str());
15052 }
15053
15054 // add dbtypes attribute
15055 hid_t tb_set = H5Dopen2(file_, title, H5P_DEFAULT);
15056 hid_t attr_space = H5Screate_simple(1, &nvals, &nvals);
15057 hid_t dbtypes_attr = H5Acreate2(tb_set, "cyclus_dbtypes", H5T_NATIVE_INT,
15058 attr_space, H5P_DEFAULT, H5P_DEFAULT);
15059 H5Awrite(dbtypes_attr, H5T_NATIVE_INT, dbtypes);
15060 H5Aclose(dbtypes_attr);
15061 H5Sclose(attr_space);
15062 for(int i = 0; i < nvals; ++i) {
15063 shape = shapes[i];
15064 hsize_t nshape = shape.size();
15065 // if no shape is present, we set a primitive size of 1.
15066 if(shape.size() == 0) {
15067 nshape = 1;
15068 }
15069 hid_t shape_space = H5Screate_simple(1, &nshape, &nshape);
15070 std::vector<int> shape_vector;
15071 for(int j = 0; j < shape.size(); ++j) {
15072 shape_vector.push_back(shape[j]);
15073 }
15074 // default shape value is -1, which denotes primitives
15075 if(shape.size() == 0) {
15076 shape_vector.push_back(-1);
15077 }
15078 std::stringstream col_name;
15079 col_name << "shape" << i;
15080 hid_t shape_attr = H5Acreate2(tb_set, col_name.str().c_str(), H5T_NATIVE_INT,
15081 shape_space, H5P_DEFAULT, H5P_DEFAULT);
15082 H5Awrite(shape_attr, H5T_NATIVE_INT, &shape_vector[0]);
15083 H5Aclose(shape_attr);
15084 H5Sclose(shape_space);
15085 }
15086 H5Dclose(tb_set);
15087
15088 // record everything for later
15089 col_offsets_[d->title()] = dst_offset;
15090 schema_sizes_[d->title()] = dst_size;
15091 col_sizes_[d->title()] = dst_sizes;
15092 schemas_[d->title()] = dbtypes;
15093}
15094
15095std::map<std::string, DbTypes> Hdf5Back::ColumnTypes(std::string table) {
15096 using std::string;
15097 int i;
15098 char* colname;
15099 hid_t dset = H5Dopen2(file_, table.c_str(), H5P_DEFAULT);
15100 hid_t dt = H5Dget_type(dset);
15101 hsize_t ncols = H5Tget_nmembers(dt);
15102 string fieldname;
15103 string fieldtype;
15104 LoadTableTypes(table, dset, ncols);
15105 DbTypes* dbtypes = schemas_[table];
15106
15107 // create return value
15108 std::map<string, DbTypes> rtn;
15109 for (i = 0; i < ncols; ++i) {
15110 colname = H5Tget_member_name(dt, i);
15111 fieldname = string(colname);
15112 free(colname);
15113 rtn[fieldname] = dbtypes[i];
15114 }
15115
15116 // close and return
15117 H5Tclose(dt);
15118 H5Dclose(dset);
15119 return rtn;
15120}
15121
15122std::list<ColumnInfo> Hdf5Back::Schema(std::string table) {
15123 std::list<ColumnInfo> schema;
15124 hid_t tb_set = H5Dopen2(file_, table.c_str(), H5P_DEFAULT);
15125 hid_t tb_type = H5Dget_type(tb_set);
15126 int i;
15127 hsize_t ncols = H5Tget_nmembers(tb_type);
15128 LoadTableTypes(table, tb_set, ncols);
15129 DbTypes* dbtypes = schemas_[table];
15130 char * colname;
15131
15132 for (i = 0; i < ncols; ++i) {
15133 colname = H5Tget_member_name(tb_type, i);
15134 std::stringstream attr_name;
15135 attr_name << "shape" << i;
15136 hid_t attr_id = H5Aopen_by_name(tb_set, ".", attr_name.str().c_str(), H5P_DEFAULT, H5P_DEFAULT);
15137 hid_t attr_space = H5Aget_space(attr_id);
15138 int ndims = H5Sget_simple_extent_npoints(attr_space);
15139 std::vector<int> shape(ndims);
15140 H5Aread(attr_id, H5T_NATIVE_INT, &shape[0]);
15141 std::string colname_str = std::string(colname);
15142 ColumnInfo info = ColumnInfo(table, colname_str, i, dbtypes[i], shape);
15143 schema.push_back(info);
15144 free(colname);
15145 H5Sclose(attr_space);
15146 H5Aclose(attr_id);
15147 }
15148 H5Tclose(tb_type);
15149 H5Dclose(tb_set);
15150
15151 return schema;
15152}
15153
15154std::set<std::string> Hdf5Back::Tables() {
15155 using std::set;
15156 using std::string;
15157 set<string> rtn;
15158 hsize_t i;
15159 hsize_t n;
15160 ssize_t namelen;
15161 char name[500];
15162 H5G_info_t root_info;
15163 hid_t root = H5Gopen(file_, "/", H5P_DEFAULT);
15164 herr_t err = H5Gget_info(root, &root_info);
15165 for (i = 0; i < root_info.nlinks; ++i) {
15166 namelen = H5Lget_name_by_idx(root, ".", H5_INDEX_NAME, H5_ITER_NATIVE, i,
15167 NULL, 0, H5P_DEFAULT);
15168 H5Lget_name_by_idx(root, ".", H5_INDEX_NAME, H5_ITER_NATIVE, i,
15169 name, namelen+1, H5P_DEFAULT);
15170 std::string str_name = std::string(name, namelen);
15171 if (str_name.size() >= 4 && str_name.substr(str_name.size()-4) != "Keys" && str_name.substr(str_name.size()-4) != "Vals") {
15172 rtn.insert(str_name);
15173 } else if (str_name.size() < 4) {
15174 rtn.insert(str_name);
15175 }
15176 }
15177 H5Gclose(root);
15178 return rtn;
15179}
15180
15181void Hdf5Back::WriteGroup(DatumList& group) {
15182 std::string title = group.front()->title();
15183 const char * c_title = title.c_str();
15184
15185 size_t* offsets = col_offsets_[title];
15186 size_t* sizes = col_sizes_[title];
15187 size_t rowsize = schema_sizes_[title];
15188
15189 char* buf = new char[group.size() * rowsize];
15190 FillBuf(title, buf, group, sizes, rowsize);
15191
15192 // We cannot do the simple thing (append_records) here because of a bug in
15193 // H5TB where it stupidly tries to reconstruct the datatype in memory from
15194 // what it read in on disk. This works in most cases but failed where the table
15195 // had a column which is an array of a compound datatype of non-homogenous
15196 // fields (eg MAP_INT_DOUBLE). The fix here just uses the datatype present on
15197 // disk - which is what we wanted anyway!
15198 //herr_t status = H5TBappend_records(file_, title.c_str(), group.size(), rowsize,
15199 // offsets, sizes, buf);
15200 herr_t status;
15201 hid_t dset = H5Dopen2(file_, title.c_str(), H5P_DEFAULT);
15202 hid_t dtype = H5Dget_type(dset);
15203 hsize_t nrecords_add = group.size();
15204 hsize_t nrecords_orig;
15205 hsize_t nfields;
15206 hsize_t dims[1];
15207 hsize_t offset[1];
15208 hsize_t count[1];
15209 H5TBget_table_info(file_, c_title, &nfields, &nrecords_orig);
15210 dims[0] = nrecords_add + nrecords_orig;
15211 offset[0] = nrecords_orig;
15212 count[0] = nrecords_add;
15213
15214 status = H5Dset_extent(dset, dims);
15215 hid_t dspace = H5Dget_space(dset);
15216 hid_t memspace = H5Screate_simple(1, count, NULL);
15217 status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, offset, NULL, count, NULL);
15218 status = H5Dwrite(dset, dtype, memspace, dspace, H5P_DEFAULT, buf);
15219
15220 if (status < 0) {
15221 std::stringstream ss;
15222 ss << "Failed to write to the HDF5 table:\n" \
15223 << " file " << path_ << "\n" \
15224 << " table " << title << "\n" \
15225 << " num. rows " << group.size() << "\n"
15226 << " rowsize " << rowsize << "\n";
15227 for (int i = 0; i < group.front()->vals().size(); ++i) {
15228 ss << " # Column " << i << "\n" \
15229 << " dbtype: " << schemas_[title][i] << "\n" \
15230 << " size: " << sizes[i] << "\n" \
15231 << " offset: " << offsets[i] << "\n";
15232 }
15233 throw IOError(ss.str());
15234 }
15235
15236 H5Sclose(memspace);
15237 H5Sclose(dspace);
15238 H5Tclose(dtype);
15239 H5Dclose(dset);
15240 delete[] buf;
15241}
15242
15243template <typename T, DbTypes U>
15244Digest Hdf5Back::VLWrite(const T& x) {
15245 hasher_.Clear();
15246 hasher_.Update(x);
15247 Digest key = hasher_.digest();
15248 hid_t keysds = VLDataset(U, true);
15249 hid_t valsds = VLDataset(U, false);
15250 if (vlkeys_[U].count(key) == 1)
15251 return key;
15252 hvl_t buf = VLValToBuf(x);
15253 AppendVLKey(keysds, U, key);
15254 InsertVLVal(valsds, U, key, buf);
15255 return key;
15256}
15257
15258template <>
15259Digest Hdf5Back::VLWrite<std::string, VL_STRING>(const std::string& x) {
15260 hasher_.Clear();
15261 hasher_.Update(x);
15262 Digest key = hasher_.digest();
15263 hid_t keysds = VLDataset(VL_STRING, true);
15264 hid_t valsds = VLDataset(VL_STRING, false);
15265 if (vlkeys_[VL_STRING].count(key) == 1)
15266 return key;
15267 AppendVLKey(keysds, VL_STRING, key);
15268 InsertVLVal(valsds, VL_STRING, key, x);
15269 return key;
15270}
15271
15272template <>
15273Digest Hdf5Back::VLWrite<Blob, BLOB>(const Blob& x) {
15274 hasher_.Clear();
15275 hasher_.Update(x);
15276 Digest key = hasher_.digest();
15277 hid_t keysds = VLDataset(BLOB, true);
15278 hid_t valsds = VLDataset(BLOB, false);
15279 if (vlkeys_[BLOB].count(key) == 1)
15280 return key;
15281 AppendVLKey(keysds, BLOB, key);
15282 InsertVLVal(valsds, BLOB, key, x.str());
15283 return key;
15284}
15285
15286template<>
15287void Hdf5Back::WriteToBuf<BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15288 const void* val0;
15289 val0=a->castsmallvoid();
15290 size_t item_size0=sizeof(char);
15291 memcpy(buf, val0, column);
15292}
15293template<>
15294void Hdf5Back::WriteToBuf<INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15295 const void* val0;
15296 val0=a->castsmallvoid();
15297 size_t item_size0=sizeof(int);
15298 memcpy(buf, val0, column);
15299}
15300template<>
15301void Hdf5Back::WriteToBuf<FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15302 const void* val0;
15303 val0=a->castsmallvoid();
15304 size_t item_size0=sizeof(float);
15305 memcpy(buf, val0, column);
15306}
15307template<>
15308void Hdf5Back::WriteToBuf<DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15309 const void* val0;
15310 val0=a->castsmallvoid();
15311 size_t item_size0=sizeof(double);
15312 memcpy(buf, val0, column);
15313}
15314template<>
15315void Hdf5Back::WriteToBuf<STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15316 std::string val0=a->cast<std::string>();
15317 size_t item_size0=shape[0];
15318 size_t valuelen0;
15319 valuelen0=std::min(val0.size(), item_size0);
15320 memcpy(buf, val0.c_str(), valuelen0);
15321 memset(buf+valuelen0, 0, item_size0-valuelen0);
15322}
15323template<>
15324void Hdf5Back::WriteToBuf<VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15325 std::string val0=a->cast<std::string>();
15326 size_t item_size0=CYCLUS_SHA1_SIZE;
15327 hasher_.Clear();
15328 hasher_.Update(val0);
15329 Digest key0 = hasher_.digest();
15330 hid_t keysds0 = VLDataset(VL_STRING, true);
15331 hid_t valsds0 = VLDataset(VL_STRING, false);
15332 if (vlkeys_[VL_STRING].count(key0) != 1) {
15333 AppendVLKey(keysds0, VL_STRING, key0);
15334 InsertVLVal(valsds0, VL_STRING, key0, val0);
15335 }
15336 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15337}
15338template<>
15339void Hdf5Back::WriteToBuf<BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15340 cyclus::Blob val0=a->cast<cyclus::Blob>();
15341 size_t item_size0=CYCLUS_SHA1_SIZE;
15342 hasher_.Clear();
15343 hasher_.Update(val0);
15344 Digest key0 = hasher_.digest();
15345 hid_t keysds0 = VLDataset(BLOB, true);
15346 hid_t valsds0 = VLDataset(BLOB, false);
15347 if (vlkeys_[BLOB].count(key0) != 1) {
15348 AppendVLKey(keysds0, BLOB, key0);
15349 InsertVLVal(valsds0, BLOB, key0, (val0).str());
15350 }
15351 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15352}
15353template<>
15354void Hdf5Back::WriteToBuf<UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15355 boost::uuids::uuid val0=a->cast<boost::uuids::uuid>();
15356 size_t item_size0=CYCLUS_UUID_SIZE;
15357 memcpy(buf, &(val0), item_size0);
15358}
15359template<>
15360void Hdf5Back::WriteToBuf<VECTOR_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15361 std::vector<int> val0=a->cast<std::vector<int>>();
15362 size_t item_size0=((sizeof(int))*shape[0]);
15363 size_t length0=shape[0];
15364 size_t item_size1elem=sizeof(int);
15365 size_t total_item_size0=item_size1elem;
15366 if(total_item_size0*val0.size()>column){
15367 std::vector<int>::iterator eraseit=val0.begin();
15368 std::advance(eraseit, column/total_item_size0);
15369 val0.erase(eraseit,val0.end());
15370
15371 }
15372 unsigned int count0=0;
15373 std::vector<int>::iterator it0=val0.begin();
15374 for(;it0!=val0.end();++it0){
15375 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15376 ++count0;
15377
15378 }
15379 if(total_item_size0*length0<column){
15380 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15381
15382 }
15383}
15384template<>
15385void Hdf5Back::WriteToBuf<VL_VECTOR_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15386 std::vector<int> val0=a->cast<std::vector<int>>();
15387 size_t item_size0=(CYCLUS_SHA1_SIZE);
15388 size_t item_size1elem=sizeof(int);
15389 size_t total_item_size0=item_size1elem;
15390 hasher_.Clear();
15391 hasher_.Update(val0);
15392 Digest key0 = hasher_.digest();
15393 hid_t keysds0 = VLDataset(VL_VECTOR_INT, true);
15394 hid_t valsds0 = VLDataset(VL_VECTOR_INT, false);
15395 if (vlkeys_[VL_VECTOR_INT].count(key0) != 1) {
15396 hvl_t buf0 = VLValToBuf(val0);
15397 AppendVLKey(keysds0, VL_VECTOR_INT, key0);
15398 InsertVLVal(valsds0, VL_VECTOR_INT, key0, buf0);
15399 }
15400 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15401}
15402template<>
15403void Hdf5Back::WriteToBuf<VECTOR_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15404 std::vector<float> val0=a->cast<std::vector<float>>();
15405 size_t item_size0=((sizeof(float))*shape[0]);
15406 size_t length0=shape[0];
15407 size_t item_size1elem=sizeof(float);
15408 size_t total_item_size0=item_size1elem;
15409 if(total_item_size0*val0.size()>column){
15410 std::vector<float>::iterator eraseit=val0.begin();
15411 std::advance(eraseit, column/total_item_size0);
15412 val0.erase(eraseit,val0.end());
15413
15414 }
15415 unsigned int count0=0;
15416 std::vector<float>::iterator it0=val0.begin();
15417 for(;it0!=val0.end();++it0){
15418 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15419 ++count0;
15420
15421 }
15422 if(total_item_size0*length0<column){
15423 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15424
15425 }
15426}
15427template<>
15428void Hdf5Back::WriteToBuf<VL_VECTOR_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15429 std::vector<float> val0=a->cast<std::vector<float>>();
15430 size_t item_size0=(CYCLUS_SHA1_SIZE);
15431 size_t item_size1elem=sizeof(float);
15432 size_t total_item_size0=item_size1elem;
15433 hasher_.Clear();
15434 hasher_.Update(val0);
15435 Digest key0 = hasher_.digest();
15436 hid_t keysds0 = VLDataset(VL_VECTOR_FLOAT, true);
15437 hid_t valsds0 = VLDataset(VL_VECTOR_FLOAT, false);
15438 if (vlkeys_[VL_VECTOR_FLOAT].count(key0) != 1) {
15439 hvl_t buf0 = VLValToBuf(val0);
15440 AppendVLKey(keysds0, VL_VECTOR_FLOAT, key0);
15441 InsertVLVal(valsds0, VL_VECTOR_FLOAT, key0, buf0);
15442 }
15443 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15444}
15445template<>
15446void Hdf5Back::WriteToBuf<VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15447 std::vector<double> val0=a->cast<std::vector<double>>();
15448 size_t item_size0=((sizeof(double))*shape[0]);
15449 size_t length0=shape[0];
15450 size_t item_size1elem=sizeof(double);
15451 size_t total_item_size0=item_size1elem;
15452 if(total_item_size0*val0.size()>column){
15453 std::vector<double>::iterator eraseit=val0.begin();
15454 std::advance(eraseit, column/total_item_size0);
15455 val0.erase(eraseit,val0.end());
15456
15457 }
15458 unsigned int count0=0;
15459 std::vector<double>::iterator it0=val0.begin();
15460 for(;it0!=val0.end();++it0){
15461 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15462 ++count0;
15463
15464 }
15465 if(total_item_size0*length0<column){
15466 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15467
15468 }
15469}
15470template<>
15471void Hdf5Back::WriteToBuf<VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15472 std::vector<double> val0=a->cast<std::vector<double>>();
15473 size_t item_size0=(CYCLUS_SHA1_SIZE);
15474 size_t item_size1elem=sizeof(double);
15475 size_t total_item_size0=item_size1elem;
15476 hasher_.Clear();
15477 hasher_.Update(val0);
15478 Digest key0 = hasher_.digest();
15479 hid_t keysds0 = VLDataset(VL_VECTOR_DOUBLE, true);
15480 hid_t valsds0 = VLDataset(VL_VECTOR_DOUBLE, false);
15481 if (vlkeys_[VL_VECTOR_DOUBLE].count(key0) != 1) {
15482 hvl_t buf0 = VLValToBuf(val0);
15483 AppendVLKey(keysds0, VL_VECTOR_DOUBLE, key0);
15484 InsertVLVal(valsds0, VL_VECTOR_DOUBLE, key0, buf0);
15485 }
15486 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15487}
15488template<>
15489void Hdf5Back::WriteToBuf<VECTOR_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15490 std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15491 size_t item_size0=((shape[1])*shape[0]);
15492 size_t length0=shape[0];
15493 size_t item_size1elem=shape[1];
15494 size_t valuelen1elem;
15495 size_t total_item_size0=item_size1elem;
15496 if(total_item_size0*val0.size()>column){
15497 std::vector<std::string>::iterator eraseit=val0.begin();
15498 std::advance(eraseit, column/total_item_size0);
15499 val0.erase(eraseit,val0.end());
15500
15501 }
15502 unsigned int count0=0;
15503 std::vector<std::string>::iterator it0=val0.begin();
15504 for(;it0!=val0.end();++it0){
15505 valuelen1elem=std::min(it0->size(), item_size1elem);
15506 memcpy(buf+item_size1elem*count0, it0->c_str(), valuelen1elem);
15507 memset(buf+item_size1elem*count0+valuelen1elem, 0, item_size1elem-valuelen1elem);
15508 ++count0;
15509
15510 }
15511 if(total_item_size0*length0<column){
15512 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15513
15514 }
15515}
15516template<>
15517void Hdf5Back::WriteToBuf<VL_VECTOR_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15518 std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15519 size_t item_size0=(CYCLUS_SHA1_SIZE);
15520 size_t item_size1elem=shape[1];
15521 size_t valuelen1elem;
15522 size_t total_item_size0=item_size1elem;
15523 unsigned int count0=0;
15524 std::vector<std::string>::iterator it0=val0.begin();
15525 std::vector<std::string> fixed_val0;
15526 unsigned int pad_count0=0;
15527 for(;it0!=val0.end();++it0){
15528 std::string child1elem=std::string((*it0),0,item_size1elem);
15529 fixed_val0.push_back(child1elem);
15530 ++pad_count0;
15531
15532 }
15533 hasher_.Clear();
15534 hasher_.Update(fixed_val0);
15535 Digest key0 = hasher_.digest();
15536 hid_t keysds0 = VLDataset(VL_VECTOR_STRING, true);
15537 hid_t valsds0 = VLDataset(VL_VECTOR_STRING, false);
15538 if (vlkeys_[VL_VECTOR_STRING].count(key0) != 1) {
15539 hvl_t buf0 = VLValToBuf(fixed_val0);
15540 AppendVLKey(keysds0, VL_VECTOR_STRING, key0);
15541 InsertVLVal(valsds0, VL_VECTOR_STRING, key0, buf0);
15542 }
15543 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15544}
15545template<>
15546void Hdf5Back::WriteToBuf<VECTOR_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15547 std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15548 size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15549 size_t length0=shape[0];
15550 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15551 size_t total_item_size0=item_size1elem;
15552 if(total_item_size0*val0.size()>column){
15553 std::vector<std::string>::iterator eraseit=val0.begin();
15554 std::advance(eraseit, column/total_item_size0);
15555 val0.erase(eraseit,val0.end());
15556
15557 }
15558 unsigned int count0=0;
15559 std::vector<std::string>::iterator it0=val0.begin();
15560 for(;it0!=val0.end();++it0){
15561 hasher_.Clear();
15562 hasher_.Update(*it0);
15563 Digest key1elem = hasher_.digest();
15564 hid_t keysds1elem = VLDataset(VL_STRING, true);
15565 hid_t valsds1elem = VLDataset(VL_STRING, false);
15566 if (vlkeys_[VL_STRING].count(key1elem) != 1) {
15567 AppendVLKey(keysds1elem, VL_STRING, key1elem);
15568 InsertVLVal(valsds1elem, VL_STRING, key1elem, *it0);
15569 }
15570 memcpy(buf+item_size1elem*count0, key1elem.data(), CYCLUS_SHA1_SIZE);
15571 ++count0;
15572
15573 }
15574 if(total_item_size0*length0<column){
15575 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15576
15577 }
15578}
15579template<>
15580void Hdf5Back::WriteToBuf<VL_VECTOR_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15581 std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15582 size_t item_size0=(CYCLUS_SHA1_SIZE);
15583 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15584 size_t total_item_size0=item_size1elem;
15585 hasher_.Clear();
15586 hasher_.Update(val0);
15587 Digest key0 = hasher_.digest();
15588 hid_t keysds0 = VLDataset(VL_VECTOR_VL_STRING, true);
15589 hid_t valsds0 = VLDataset(VL_VECTOR_VL_STRING, false);
15590 if (vlkeys_[VL_VECTOR_VL_STRING].count(key0) != 1) {
15591 hvl_t buf0 = VLValToBuf(val0);
15592 AppendVLKey(keysds0, VL_VECTOR_VL_STRING, key0);
15593 InsertVLVal(valsds0, VL_VECTOR_VL_STRING, key0, buf0);
15594 }
15595 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15596}
15597template<>
15598void Hdf5Back::WriteToBuf<VECTOR_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15599 std::vector<cyclus::Blob> val0=a->cast<std::vector<cyclus::Blob>>();
15600 size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15601 size_t length0=shape[0];
15602 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15603 size_t total_item_size0=item_size1elem;
15604 if(total_item_size0*val0.size()>column){
15605 std::vector<cyclus::Blob>::iterator eraseit=val0.begin();
15606 std::advance(eraseit, column/total_item_size0);
15607 val0.erase(eraseit,val0.end());
15608
15609 }
15610 unsigned int count0=0;
15611 std::vector<cyclus::Blob>::iterator it0=val0.begin();
15612 for(;it0!=val0.end();++it0){
15613 hasher_.Clear();
15614 hasher_.Update(*it0);
15615 Digest key1elem = hasher_.digest();
15616 hid_t keysds1elem = VLDataset(BLOB, true);
15617 hid_t valsds1elem = VLDataset(BLOB, false);
15618 if (vlkeys_[BLOB].count(key1elem) != 1) {
15619 AppendVLKey(keysds1elem, BLOB, key1elem);
15620 InsertVLVal(valsds1elem, BLOB, key1elem, (*it0).str());
15621 }
15622 memcpy(buf+item_size1elem*count0, key1elem.data(), CYCLUS_SHA1_SIZE);
15623 ++count0;
15624
15625 }
15626 if(total_item_size0*length0<column){
15627 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15628
15629 }
15630}
15631template<>
15632void Hdf5Back::WriteToBuf<VL_VECTOR_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15633 std::vector<cyclus::Blob> val0=a->cast<std::vector<cyclus::Blob>>();
15634 size_t item_size0=(CYCLUS_SHA1_SIZE);
15635 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15636 size_t total_item_size0=item_size1elem;
15637 hasher_.Clear();
15638 hasher_.Update(val0);
15639 Digest key0 = hasher_.digest();
15640 hid_t keysds0 = VLDataset(VL_VECTOR_BLOB, true);
15641 hid_t valsds0 = VLDataset(VL_VECTOR_BLOB, false);
15642 if (vlkeys_[VL_VECTOR_BLOB].count(key0) != 1) {
15643 hvl_t buf0 = VLValToBuf(val0);
15644 AppendVLKey(keysds0, VL_VECTOR_BLOB, key0);
15645 InsertVLVal(valsds0, VL_VECTOR_BLOB, key0, buf0);
15646 }
15647 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15648}
15649template<>
15650void Hdf5Back::WriteToBuf<VECTOR_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15651 std::vector<boost::uuids::uuid> val0=a->cast<std::vector<boost::uuids::uuid>>();
15652 size_t item_size0=((CYCLUS_UUID_SIZE)*shape[0]);
15653 size_t length0=shape[0];
15654 size_t item_size1elem=CYCLUS_UUID_SIZE;
15655 size_t total_item_size0=item_size1elem;
15656 if(total_item_size0*val0.size()>column){
15657 std::vector<boost::uuids::uuid>::iterator eraseit=val0.begin();
15658 std::advance(eraseit, column/total_item_size0);
15659 val0.erase(eraseit,val0.end());
15660
15661 }
15662 unsigned int count0=0;
15663 std::vector<boost::uuids::uuid>::iterator it0=val0.begin();
15664 for(;it0!=val0.end();++it0){
15665 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15666 ++count0;
15667
15668 }
15669 if(total_item_size0*length0<column){
15670 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15671
15672 }
15673}
15674template<>
15675void Hdf5Back::WriteToBuf<VL_VECTOR_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15676 std::vector<boost::uuids::uuid> val0=a->cast<std::vector<boost::uuids::uuid>>();
15677 size_t item_size0=(CYCLUS_SHA1_SIZE);
15678 size_t item_size1elem=CYCLUS_UUID_SIZE;
15679 size_t total_item_size0=item_size1elem;
15680 hasher_.Clear();
15681 hasher_.Update(val0);
15682 Digest key0 = hasher_.digest();
15683 hid_t keysds0 = VLDataset(VL_VECTOR_UUID, true);
15684 hid_t valsds0 = VLDataset(VL_VECTOR_UUID, false);
15685 if (vlkeys_[VL_VECTOR_UUID].count(key0) != 1) {
15686 hvl_t buf0 = VLValToBuf(val0);
15687 AppendVLKey(keysds0, VL_VECTOR_UUID, key0);
15688 InsertVLVal(valsds0, VL_VECTOR_UUID, key0, buf0);
15689 }
15690 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15691}
15692template<>
15693void Hdf5Back::WriteToBuf<SET_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15694 std::set<int> val0=a->cast<std::set<int>>();
15695 size_t item_size0=((sizeof(int))*shape[0]);
15696 size_t length0=shape[0];
15697 size_t item_size1elem=sizeof(int);
15698 size_t total_item_size0=item_size1elem;
15699 if(total_item_size0*val0.size()>column){
15700 std::set<int>::iterator eraseit=val0.begin();
15701 std::advance(eraseit, column/total_item_size0);
15702 val0.erase(eraseit,val0.end());
15703
15704 }
15705 unsigned int count0=0;
15706 std::set<int>::iterator it0=val0.begin();
15707 for(;it0!=val0.end();++it0){
15708 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15709 ++count0;
15710
15711 }
15712 if(total_item_size0*length0<column){
15713 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15714
15715 }
15716}
15717template<>
15718void Hdf5Back::WriteToBuf<VL_SET_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15719 std::set<int> val0=a->cast<std::set<int>>();
15720 size_t item_size0=(CYCLUS_SHA1_SIZE);
15721 size_t item_size1elem=sizeof(int);
15722 size_t total_item_size0=item_size1elem;
15723 hasher_.Clear();
15724 hasher_.Update(val0);
15725 Digest key0 = hasher_.digest();
15726 hid_t keysds0 = VLDataset(VL_SET_INT, true);
15727 hid_t valsds0 = VLDataset(VL_SET_INT, false);
15728 if (vlkeys_[VL_SET_INT].count(key0) != 1) {
15729 hvl_t buf0 = VLValToBuf(val0);
15730 AppendVLKey(keysds0, VL_SET_INT, key0);
15731 InsertVLVal(valsds0, VL_SET_INT, key0, buf0);
15732 }
15733 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15734}
15735template<>
15736void Hdf5Back::WriteToBuf<SET_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15737 std::set<float> val0=a->cast<std::set<float>>();
15738 size_t item_size0=((sizeof(float))*shape[0]);
15739 size_t length0=shape[0];
15740 size_t item_size1elem=sizeof(float);
15741 size_t total_item_size0=item_size1elem;
15742 if(total_item_size0*val0.size()>column){
15743 std::set<float>::iterator eraseit=val0.begin();
15744 std::advance(eraseit, column/total_item_size0);
15745 val0.erase(eraseit,val0.end());
15746
15747 }
15748 unsigned int count0=0;
15749 std::set<float>::iterator it0=val0.begin();
15750 for(;it0!=val0.end();++it0){
15751 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15752 ++count0;
15753
15754 }
15755 if(total_item_size0*length0<column){
15756 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15757
15758 }
15759}
15760template<>
15761void Hdf5Back::WriteToBuf<VL_SET_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15762 std::set<float> val0=a->cast<std::set<float>>();
15763 size_t item_size0=(CYCLUS_SHA1_SIZE);
15764 size_t item_size1elem=sizeof(float);
15765 size_t total_item_size0=item_size1elem;
15766 hasher_.Clear();
15767 hasher_.Update(val0);
15768 Digest key0 = hasher_.digest();
15769 hid_t keysds0 = VLDataset(VL_SET_FLOAT, true);
15770 hid_t valsds0 = VLDataset(VL_SET_FLOAT, false);
15771 if (vlkeys_[VL_SET_FLOAT].count(key0) != 1) {
15772 hvl_t buf0 = VLValToBuf(val0);
15773 AppendVLKey(keysds0, VL_SET_FLOAT, key0);
15774 InsertVLVal(valsds0, VL_SET_FLOAT, key0, buf0);
15775 }
15776 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15777}
15778template<>
15779void Hdf5Back::WriteToBuf<SET_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15780 std::set<double> val0=a->cast<std::set<double>>();
15781 size_t item_size0=((sizeof(double))*shape[0]);
15782 size_t length0=shape[0];
15783 size_t item_size1elem=sizeof(double);
15784 size_t total_item_size0=item_size1elem;
15785 if(total_item_size0*val0.size()>column){
15786 std::set<double>::iterator eraseit=val0.begin();
15787 std::advance(eraseit, column/total_item_size0);
15788 val0.erase(eraseit,val0.end());
15789
15790 }
15791 unsigned int count0=0;
15792 std::set<double>::iterator it0=val0.begin();
15793 for(;it0!=val0.end();++it0){
15794 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15795 ++count0;
15796
15797 }
15798 if(total_item_size0*length0<column){
15799 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15800
15801 }
15802}
15803template<>
15804void Hdf5Back::WriteToBuf<VL_SET_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15805 std::set<double> val0=a->cast<std::set<double>>();
15806 size_t item_size0=(CYCLUS_SHA1_SIZE);
15807 size_t item_size1elem=sizeof(double);
15808 size_t total_item_size0=item_size1elem;
15809 hasher_.Clear();
15810 hasher_.Update(val0);
15811 Digest key0 = hasher_.digest();
15812 hid_t keysds0 = VLDataset(VL_SET_DOUBLE, true);
15813 hid_t valsds0 = VLDataset(VL_SET_DOUBLE, false);
15814 if (vlkeys_[VL_SET_DOUBLE].count(key0) != 1) {
15815 hvl_t buf0 = VLValToBuf(val0);
15816 AppendVLKey(keysds0, VL_SET_DOUBLE, key0);
15817 InsertVLVal(valsds0, VL_SET_DOUBLE, key0, buf0);
15818 }
15819 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15820}
15821template<>
15822void Hdf5Back::WriteToBuf<SET_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15823 std::set<std::string> val0=a->cast<std::set<std::string>>();
15824 size_t item_size0=((shape[1])*shape[0]);
15825 size_t length0=shape[0];
15826 size_t item_size1elem=shape[1];
15827 size_t valuelen1elem;
15828 size_t total_item_size0=item_size1elem;
15829 if(total_item_size0*val0.size()>column){
15830 std::set<std::string>::iterator eraseit=val0.begin();
15831 std::advance(eraseit, column/total_item_size0);
15832 val0.erase(eraseit,val0.end());
15833
15834 }
15835 unsigned int count0=0;
15836 std::set<std::string>::iterator it0=val0.begin();
15837 for(;it0!=val0.end();++it0){
15838 valuelen1elem=std::min(it0->size(), item_size1elem);
15839 memcpy(buf+item_size1elem*count0, it0->c_str(), valuelen1elem);
15840 memset(buf+item_size1elem*count0+valuelen1elem, 0, item_size1elem-valuelen1elem);
15841 ++count0;
15842
15843 }
15844 if(total_item_size0*length0<column){
15845 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15846
15847 }
15848}
15849template<>
15850void Hdf5Back::WriteToBuf<VL_SET_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15851 std::set<std::string> val0=a->cast<std::set<std::string>>();
15852 size_t item_size0=(CYCLUS_SHA1_SIZE);
15853 size_t item_size1elem=shape[1];
15854 size_t valuelen1elem;
15855 size_t total_item_size0=item_size1elem;
15856 unsigned int count0=0;
15857 std::set<std::string>::iterator it0=val0.begin();
15858 std::set<std::string> fixed_val0;
15859 unsigned int pad_count0=0;
15860 for(;it0!=val0.end();++it0){
15861 std::string child1elem=std::string((*it0),0,item_size1elem);
15862 fixed_val0.insert(child1elem);
15863 ++pad_count0;
15864
15865 }
15866 hasher_.Clear();
15867 hasher_.Update(fixed_val0);
15868 Digest key0 = hasher_.digest();
15869 hid_t keysds0 = VLDataset(VL_SET_STRING, true);
15870 hid_t valsds0 = VLDataset(VL_SET_STRING, false);
15871 if (vlkeys_[VL_SET_STRING].count(key0) != 1) {
15872 hvl_t buf0 = VLValToBuf(fixed_val0);
15873 AppendVLKey(keysds0, VL_SET_STRING, key0);
15874 InsertVLVal(valsds0, VL_SET_STRING, key0, buf0);
15875 }
15876 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15877}
15878template<>
15879void Hdf5Back::WriteToBuf<SET_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15880 std::set<std::string> val0=a->cast<std::set<std::string>>();
15881 size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15882 size_t length0=shape[0];
15883 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15884 size_t total_item_size0=item_size1elem;
15885 if(total_item_size0*val0.size()>column){
15886 std::set<std::string>::iterator eraseit=val0.begin();
15887 std::advance(eraseit, column/total_item_size0);
15888 val0.erase(eraseit,val0.end());
15889
15890 }
15891 unsigned int count0=0;
15892 std::set<std::string>::iterator it0=val0.begin();
15893 for(;it0!=val0.end();++it0){
15894 hasher_.Clear();
15895 hasher_.Update(*it0);
15896 Digest key1elem = hasher_.digest();
15897 hid_t keysds1elem = VLDataset(VL_STRING, true);
15898 hid_t valsds1elem = VLDataset(VL_STRING, false);
15899 if (vlkeys_[VL_STRING].count(key1elem) != 1) {
15900 AppendVLKey(keysds1elem, VL_STRING, key1elem);
15901 InsertVLVal(valsds1elem, VL_STRING, key1elem, *it0);
15902 }
15903 memcpy(buf+item_size1elem*count0, key1elem.data(), CYCLUS_SHA1_SIZE);
15904 ++count0;
15905
15906 }
15907 if(total_item_size0*length0<column){
15908 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15909
15910 }
15911}
15912template<>
15913void Hdf5Back::WriteToBuf<VL_SET_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15914 std::set<std::string> val0=a->cast<std::set<std::string>>();
15915 size_t item_size0=(CYCLUS_SHA1_SIZE);
15916 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15917 size_t total_item_size0=item_size1elem;
15918 hasher_.Clear();
15919 hasher_.Update(val0);
15920 Digest key0 = hasher_.digest();
15921 hid_t keysds0 = VLDataset(VL_SET_VL_STRING, true);
15922 hid_t valsds0 = VLDataset(VL_SET_VL_STRING, false);
15923 if (vlkeys_[VL_SET_VL_STRING].count(key0) != 1) {
15924 hvl_t buf0 = VLValToBuf(val0);
15925 AppendVLKey(keysds0, VL_SET_VL_STRING, key0);
15926 InsertVLVal(valsds0, VL_SET_VL_STRING, key0, buf0);
15927 }
15928 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15929}
15930template<>
15931void Hdf5Back::WriteToBuf<SET_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15932 std::set<cyclus::Blob> val0=a->cast<std::set<cyclus::Blob>>();
15933 size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15934 size_t length0=shape[0];
15935 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15936 size_t total_item_size0=item_size1elem;
15937 if(total_item_size0*val0.size()>column){
15938 std::set<cyclus::Blob>::iterator eraseit=val0.begin();
15939 std::advance(eraseit, column/total_item_size0);
15940 val0.erase(eraseit,val0.end());
15941
15942 }
15943 unsigned int count0=0;
15944 std::set<cyclus::Blob>::iterator it0=val0.begin();
15945 for(;it0!=val0.end();++it0){
15946 hasher_.Clear();
15947 hasher_.Update(*it0);
15948 Digest key1elem = hasher_.digest();
15949 hid_t keysds1elem = VLDataset(BLOB, true);
15950 hid_t valsds1elem = VLDataset(BLOB, false);
15951 if (vlkeys_[BLOB].count(key1elem) != 1) {
15952 AppendVLKey(keysds1elem, BLOB, key1elem);
15953 InsertVLVal(valsds1elem, BLOB, key1elem, (*it0).str());
15954 }
15955 memcpy(buf+item_size1elem*count0, key1elem.data(), CYCLUS_SHA1_SIZE);
15956 ++count0;
15957
15958 }
15959 if(total_item_size0*length0<column){
15960 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15961
15962 }
15963}
15964template<>
15965void Hdf5Back::WriteToBuf<VL_SET_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15966 std::set<cyclus::Blob> val0=a->cast<std::set<cyclus::Blob>>();
15967 size_t item_size0=(CYCLUS_SHA1_SIZE);
15968 size_t item_size1elem=CYCLUS_SHA1_SIZE;
15969 size_t total_item_size0=item_size1elem;
15970 hasher_.Clear();
15971 hasher_.Update(val0);
15972 Digest key0 = hasher_.digest();
15973 hid_t keysds0 = VLDataset(VL_SET_BLOB, true);
15974 hid_t valsds0 = VLDataset(VL_SET_BLOB, false);
15975 if (vlkeys_[VL_SET_BLOB].count(key0) != 1) {
15976 hvl_t buf0 = VLValToBuf(val0);
15977 AppendVLKey(keysds0, VL_SET_BLOB, key0);
15978 InsertVLVal(valsds0, VL_SET_BLOB, key0, buf0);
15979 }
15980 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
15981}
15982template<>
15983void Hdf5Back::WriteToBuf<SET_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15984 std::set<boost::uuids::uuid> val0=a->cast<std::set<boost::uuids::uuid>>();
15985 size_t item_size0=((CYCLUS_UUID_SIZE)*shape[0]);
15986 size_t length0=shape[0];
15987 size_t item_size1elem=CYCLUS_UUID_SIZE;
15988 size_t total_item_size0=item_size1elem;
15989 if(total_item_size0*val0.size()>column){
15990 std::set<boost::uuids::uuid>::iterator eraseit=val0.begin();
15991 std::advance(eraseit, column/total_item_size0);
15992 val0.erase(eraseit,val0.end());
15993
15994 }
15995 unsigned int count0=0;
15996 std::set<boost::uuids::uuid>::iterator it0=val0.begin();
15997 for(;it0!=val0.end();++it0){
15998 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15999 ++count0;
16000
16001 }
16002 if(total_item_size0*length0<column){
16003 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16004
16005 }
16006}
16007template<>
16008void Hdf5Back::WriteToBuf<VL_SET_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16009 std::set<boost::uuids::uuid> val0=a->cast<std::set<boost::uuids::uuid>>();
16010 size_t item_size0=(CYCLUS_SHA1_SIZE);
16011 size_t item_size1elem=CYCLUS_UUID_SIZE;
16012 size_t total_item_size0=item_size1elem;
16013 hasher_.Clear();
16014 hasher_.Update(val0);
16015 Digest key0 = hasher_.digest();
16016 hid_t keysds0 = VLDataset(VL_SET_UUID, true);
16017 hid_t valsds0 = VLDataset(VL_SET_UUID, false);
16018 if (vlkeys_[VL_SET_UUID].count(key0) != 1) {
16019 hvl_t buf0 = VLValToBuf(val0);
16020 AppendVLKey(keysds0, VL_SET_UUID, key0);
16021 InsertVLVal(valsds0, VL_SET_UUID, key0, buf0);
16022 }
16023 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16024}
16025template<>
16026void Hdf5Back::WriteToBuf<LIST_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16027 std::list<bool> val0=a->cast<std::list<bool>>();
16028 size_t item_size0=((sizeof(char))*shape[0]);
16029 size_t length0=shape[0];
16030 size_t item_size1elem=sizeof(char);
16031 size_t total_item_size0=item_size1elem;
16032 if(total_item_size0*val0.size()>column){
16033 std::list<bool>::iterator eraseit=val0.begin();
16034 std::advance(eraseit, column/total_item_size0);
16035 val0.erase(eraseit,val0.end());
16036
16037 }
16038 unsigned int count0=0;
16039 std::list<bool>::iterator it0=val0.begin();
16040 for(;it0!=val0.end();++it0){
16041 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16042 ++count0;
16043
16044 }
16045 if(total_item_size0*length0<column){
16046 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16047
16048 }
16049}
16050template<>
16051void Hdf5Back::WriteToBuf<VL_LIST_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16052 std::list<bool> val0=a->cast<std::list<bool>>();
16053 size_t item_size0=(CYCLUS_SHA1_SIZE);
16054 size_t item_size1elem=sizeof(char);
16055 size_t total_item_size0=item_size1elem;
16056 hasher_.Clear();
16057 hasher_.Update(val0);
16058 Digest key0 = hasher_.digest();
16059 hid_t keysds0 = VLDataset(VL_LIST_BOOL, true);
16060 hid_t valsds0 = VLDataset(VL_LIST_BOOL, false);
16061 if (vlkeys_[VL_LIST_BOOL].count(key0) != 1) {
16062 hvl_t buf0 = VLValToBuf(val0);
16063 AppendVLKey(keysds0, VL_LIST_BOOL, key0);
16064 InsertVLVal(valsds0, VL_LIST_BOOL, key0, buf0);
16065 }
16066 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16067}
16068template<>
16069void Hdf5Back::WriteToBuf<LIST_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16070 std::list<int> val0=a->cast<std::list<int>>();
16071 size_t item_size0=((sizeof(int))*shape[0]);
16072 size_t length0=shape[0];
16073 size_t item_size1elem=sizeof(int);
16074 size_t total_item_size0=item_size1elem;
16075 if(total_item_size0*val0.size()>column){
16076 std::list<int>::iterator eraseit=val0.begin();
16077 std::advance(eraseit, column/total_item_size0);
16078 val0.erase(eraseit,val0.end());
16079
16080 }
16081 unsigned int count0=0;
16082 std::list<int>::iterator it0=val0.begin();
16083 for(;it0!=val0.end();++it0){
16084 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16085 ++count0;
16086
16087 }
16088 if(total_item_size0*length0<column){
16089 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16090
16091 }
16092}
16093template<>
16094void Hdf5Back::WriteToBuf<VL_LIST_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16095 std::list<int> val0=a->cast<std::list<int>>();
16096 size_t item_size0=(CYCLUS_SHA1_SIZE);
16097 size_t item_size1elem=sizeof(int);
16098 size_t total_item_size0=item_size1elem;
16099 hasher_.Clear();
16100 hasher_.Update(val0);
16101 Digest key0 = hasher_.digest();
16102 hid_t keysds0 = VLDataset(VL_LIST_INT, true);
16103 hid_t valsds0 = VLDataset(VL_LIST_INT, false);
16104 if (vlkeys_[VL_LIST_INT].count(key0) != 1) {
16105 hvl_t buf0 = VLValToBuf(val0);
16106 AppendVLKey(keysds0, VL_LIST_INT, key0);
16107 InsertVLVal(valsds0, VL_LIST_INT, key0, buf0);
16108 }
16109 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16110}
16111template<>
16112void Hdf5Back::WriteToBuf<LIST_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16113 std::list<float> val0=a->cast<std::list<float>>();
16114 size_t item_size0=((sizeof(float))*shape[0]);
16115 size_t length0=shape[0];
16116 size_t item_size1elem=sizeof(float);
16117 size_t total_item_size0=item_size1elem;
16118 if(total_item_size0*val0.size()>column){
16119 std::list<float>::iterator eraseit=val0.begin();
16120 std::advance(eraseit, column/total_item_size0);
16121 val0.erase(eraseit,val0.end());
16122
16123 }
16124 unsigned int count0=0;
16125 std::list<float>::iterator it0=val0.begin();
16126 for(;it0!=val0.end();++it0){
16127 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16128 ++count0;
16129
16130 }
16131 if(total_item_size0*length0<column){
16132 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16133
16134 }
16135}
16136template<>
16137void Hdf5Back::WriteToBuf<VL_LIST_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16138 std::list<float> val0=a->cast<std::list<float>>();
16139 size_t item_size0=(CYCLUS_SHA1_SIZE);
16140 size_t item_size1elem=sizeof(float);
16141 size_t total_item_size0=item_size1elem;
16142 hasher_.Clear();
16143 hasher_.Update(val0);
16144 Digest key0 = hasher_.digest();
16145 hid_t keysds0 = VLDataset(VL_LIST_FLOAT, true);
16146 hid_t valsds0 = VLDataset(VL_LIST_FLOAT, false);
16147 if (vlkeys_[VL_LIST_FLOAT].count(key0) != 1) {
16148 hvl_t buf0 = VLValToBuf(val0);
16149 AppendVLKey(keysds0, VL_LIST_FLOAT, key0);
16150 InsertVLVal(valsds0, VL_LIST_FLOAT, key0, buf0);
16151 }
16152 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16153}
16154template<>
16155void Hdf5Back::WriteToBuf<LIST_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16156 std::list<double> val0=a->cast<std::list<double>>();
16157 size_t item_size0=((sizeof(double))*shape[0]);
16158 size_t length0=shape[0];
16159 size_t item_size1elem=sizeof(double);
16160 size_t total_item_size0=item_size1elem;
16161 if(total_item_size0*val0.size()>column){
16162 std::list<double>::iterator eraseit=val0.begin();
16163 std::advance(eraseit, column/total_item_size0);
16164 val0.erase(eraseit,val0.end());
16165
16166 }
16167 unsigned int count0=0;
16168 std::list<double>::iterator it0=val0.begin();
16169 for(;it0!=val0.end();++it0){
16170 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16171 ++count0;
16172
16173 }
16174 if(total_item_size0*length0<column){
16175 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16176
16177 }
16178}
16179template<>
16180void Hdf5Back::WriteToBuf<VL_LIST_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16181 std::list<double> val0=a->cast<std::list<double>>();
16182 size_t item_size0=(CYCLUS_SHA1_SIZE);
16183 size_t item_size1elem=sizeof(double);
16184 size_t total_item_size0=item_size1elem;
16185 hasher_.Clear();
16186 hasher_.Update(val0);
16187 Digest key0 = hasher_.digest();
16188 hid_t keysds0 = VLDataset(VL_LIST_DOUBLE, true);
16189 hid_t valsds0 = VLDataset(VL_LIST_DOUBLE, false);
16190 if (vlkeys_[VL_LIST_DOUBLE].count(key0) != 1) {
16191 hvl_t buf0 = VLValToBuf(val0);
16192 AppendVLKey(keysds0, VL_LIST_DOUBLE, key0);
16193 InsertVLVal(valsds0, VL_LIST_DOUBLE, key0, buf0);
16194 }
16195 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16196}
16197template<>
16198void Hdf5Back::WriteToBuf<LIST_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16199 std::list<std::string> val0=a->cast<std::list<std::string>>();
16200 size_t item_size0=((shape[1])*shape[0]);
16201 size_t length0=shape[0];
16202 size_t item_size1elem=shape[1];
16203 size_t valuelen1elem;
16204 size_t total_item_size0=item_size1elem;
16205 if(total_item_size0*val0.size()>column){
16206 std::list<std::string>::iterator eraseit=val0.begin();
16207 std::advance(eraseit, column/total_item_size0);
16208 val0.erase(eraseit,val0.end());
16209
16210 }
16211 unsigned int count0=0;
16212 std::list<std::string>::iterator it0=val0.begin();
16213 for(;it0!=val0.end();++it0){
16214 valuelen1elem=std::min(it0->size(), item_size1elem);
16215 memcpy(buf+item_size1elem*count0, it0->c_str(), valuelen1elem);
16216 memset(buf+item_size1elem*count0+valuelen1elem, 0, item_size1elem-valuelen1elem);
16217 ++count0;
16218
16219 }
16220 if(total_item_size0*length0<column){
16221 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16222
16223 }
16224}
16225template<>
16226void Hdf5Back::WriteToBuf<VL_LIST_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16227 std::list<std::string> val0=a->cast<std::list<std::string>>();
16228 size_t item_size0=(CYCLUS_SHA1_SIZE);
16229 size_t item_size1elem=shape[1];
16230 size_t valuelen1elem;
16231 size_t total_item_size0=item_size1elem;
16232 unsigned int count0=0;
16233 std::list<std::string>::iterator it0=val0.begin();
16234 std::list<std::string> fixed_val0;
16235 unsigned int pad_count0=0;
16236 for(;it0!=val0.end();++it0){
16237 std::string child1elem=std::string((*it0),0,item_size1elem);
16238 fixed_val0.push_back(child1elem);
16239 ++pad_count0;
16240
16241 }
16242 hasher_.Clear();
16243 hasher_.Update(fixed_val0);
16244 Digest key0 = hasher_.digest();
16245 hid_t keysds0 = VLDataset(VL_LIST_STRING, true);
16246 hid_t valsds0 = VLDataset(VL_LIST_STRING, false);
16247 if (vlkeys_[VL_LIST_STRING].count(key0) != 1) {
16248 hvl_t buf0 = VLValToBuf(fixed_val0);
16249 AppendVLKey(keysds0, VL_LIST_STRING, key0);
16250 InsertVLVal(valsds0, VL_LIST_STRING, key0, buf0);
16251 }
16252 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16253}
16254template<>
16255void Hdf5Back::WriteToBuf<LIST_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16256 std::list<std::string> val0=a->cast<std::list<std::string>>();
16257 size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
16258 size_t length0=shape[0];
16259 size_t item_size1elem=CYCLUS_SHA1_SIZE;
16260 size_t total_item_size0=item_size1elem;
16261 if(total_item_size0*val0.size()>column){
16262 std::list<std::string>::iterator eraseit=val0.begin();
16263 std::advance(eraseit, column/total_item_size0);
16264 val0.erase(eraseit,val0.end());
16265
16266 }
16267 unsigned int count0=0;
16268 std::list<std::string>::iterator it0=val0.begin();
16269 for(;it0!=val0.end();++it0){
16270 hasher_.Clear();
16271 hasher_.Update(*it0);
16272 Digest key1elem = hasher_.digest();
16273 hid_t keysds1elem = VLDataset(VL_STRING, true);
16274 hid_t valsds1elem = VLDataset(VL_STRING, false);
16275 if (vlkeys_[VL_STRING].count(key1elem) != 1) {
16276 AppendVLKey(keysds1elem, VL_STRING, key1elem);
16277 InsertVLVal(valsds1elem, VL_STRING, key1elem, *it0);
16278 }
16279 memcpy(buf+item_size1elem*count0, key1elem.data(), CYCLUS_SHA1_SIZE);
16280 ++count0;
16281
16282 }
16283 if(total_item_size0*length0<column){
16284 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16285
16286 }
16287}
16288template<>
16289void Hdf5Back::WriteToBuf<VL_LIST_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16290 std::list<std::string> val0=a->cast<std::list<std::string>>();
16291 size_t item_size0=(CYCLUS_SHA1_SIZE);
16292 size_t item_size1elem=CYCLUS_SHA1_SIZE;
16293 size_t total_item_size0=item_size1elem;
16294 hasher_.Clear();
16295 hasher_.Update(val0);
16296 Digest key0 = hasher_.digest();
16297 hid_t keysds0 = VLDataset(VL_LIST_VL_STRING, true);
16298 hid_t valsds0 = VLDataset(VL_LIST_VL_STRING, false);
16299 if (vlkeys_[VL_LIST_VL_STRING].count(key0) != 1) {
16300 hvl_t buf0 = VLValToBuf(val0);
16301 AppendVLKey(keysds0, VL_LIST_VL_STRING, key0);
16302 InsertVLVal(valsds0, VL_LIST_VL_STRING, key0, buf0);
16303 }
16304 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16305}
16306template<>
16307void Hdf5Back::WriteToBuf<LIST_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16308 std::list<cyclus::Blob> val0=a->cast<std::list<cyclus::Blob>>();
16309 size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
16310 size_t length0=shape[0];
16311 size_t item_size1elem=CYCLUS_SHA1_SIZE;
16312 size_t total_item_size0=item_size1elem;
16313 if(total_item_size0*val0.size()>column){
16314 std::list<cyclus::Blob>::iterator eraseit=val0.begin();
16315 std::advance(eraseit, column/total_item_size0);
16316 val0.erase(eraseit,val0.end());
16317
16318 }
16319 unsigned int count0=0;
16320 std::list<cyclus::Blob>::iterator it0=val0.begin();
16321 for(;it0!=val0.end();++it0){
16322 hasher_.Clear();
16323 hasher_.Update(*it0);
16324 Digest key1elem = hasher_.digest();
16325 hid_t keysds1elem = VLDataset(BLOB, true);
16326 hid_t valsds1elem = VLDataset(BLOB, false);
16327 if (vlkeys_[BLOB].count(key1elem) != 1) {
16328 AppendVLKey(keysds1elem, BLOB, key1elem);
16329 InsertVLVal(valsds1elem, BLOB, key1elem, (*it0).str());
16330 }
16331 memcpy(buf+item_size1elem*count0, key1elem.data(), CYCLUS_SHA1_SIZE);
16332 ++count0;
16333
16334 }
16335 if(total_item_size0*length0<column){
16336 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16337
16338 }
16339}
16340template<>
16341void Hdf5Back::WriteToBuf<VL_LIST_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16342 std::list<cyclus::Blob> val0=a->cast<std::list<cyclus::Blob>>();
16343 size_t item_size0=(CYCLUS_SHA1_SIZE);
16344 size_t item_size1elem=CYCLUS_SHA1_SIZE;
16345 size_t total_item_size0=item_size1elem;
16346 hasher_.Clear();
16347 hasher_.Update(val0);
16348 Digest key0 = hasher_.digest();
16349 hid_t keysds0 = VLDataset(VL_LIST_BLOB, true);
16350 hid_t valsds0 = VLDataset(VL_LIST_BLOB, false);
16351 if (vlkeys_[VL_LIST_BLOB].count(key0) != 1) {
16352 hvl_t buf0 = VLValToBuf(val0);
16353 AppendVLKey(keysds0, VL_LIST_BLOB, key0);
16354 InsertVLVal(valsds0, VL_LIST_BLOB, key0, buf0);
16355 }
16356 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16357}
16358template<>
16359void Hdf5Back::WriteToBuf<LIST_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16360 std::list<boost::uuids::uuid> val0=a->cast<std::list<boost::uuids::uuid>>();
16361 size_t item_size0=((CYCLUS_UUID_SIZE)*shape[0]);
16362 size_t length0=shape[0];
16363 size_t item_size1elem=CYCLUS_UUID_SIZE;
16364 size_t total_item_size0=item_size1elem;
16365 if(total_item_size0*val0.size()>column){
16366 std::list<boost::uuids::uuid>::iterator eraseit=val0.begin();
16367 std::advance(eraseit, column/total_item_size0);
16368 val0.erase(eraseit,val0.end());
16369
16370 }
16371 unsigned int count0=0;
16372 std::list<boost::uuids::uuid>::iterator it0=val0.begin();
16373 for(;it0!=val0.end();++it0){
16374 memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16375 ++count0;
16376
16377 }
16378 if(total_item_size0*length0<column){
16379 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16380
16381 }
16382}
16383template<>
16384void Hdf5Back::WriteToBuf<VL_LIST_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16385 std::list<boost::uuids::uuid> val0=a->cast<std::list<boost::uuids::uuid>>();
16386 size_t item_size0=(CYCLUS_SHA1_SIZE);
16387 size_t item_size1elem=CYCLUS_UUID_SIZE;
16388 size_t total_item_size0=item_size1elem;
16389 hasher_.Clear();
16390 hasher_.Update(val0);
16391 Digest key0 = hasher_.digest();
16392 hid_t keysds0 = VLDataset(VL_LIST_UUID, true);
16393 hid_t valsds0 = VLDataset(VL_LIST_UUID, false);
16394 if (vlkeys_[VL_LIST_UUID].count(key0) != 1) {
16395 hvl_t buf0 = VLValToBuf(val0);
16396 AppendVLKey(keysds0, VL_LIST_UUID, key0);
16397 InsertVLVal(valsds0, VL_LIST_UUID, key0, buf0);
16398 }
16399 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16400}
16401template<>
16402void Hdf5Back::WriteToBuf<PAIR_INT_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16403 std::pair<int, bool> val0=a->cast<std::pair<int, bool>>();
16404 size_t item_size0=((sizeof(int)+sizeof(char)));
16405 size_t item_size1first=sizeof(int);
16406 size_t item_size1second=sizeof(char);
16407 size_t total_item_size0=item_size1first+item_size1second;
16408 unsigned int count0=0;
16409 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16410 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16411}
16412template<>
16413void Hdf5Back::WriteToBuf<PAIR_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16414 std::pair<int, int> val0=a->cast<std::pair<int, int>>();
16415 size_t item_size0=((sizeof(int)+sizeof(int)));
16416 size_t item_size1first=sizeof(int);
16417 size_t item_size1second=sizeof(int);
16418 size_t total_item_size0=item_size1first+item_size1second;
16419 unsigned int count0=0;
16420 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16421 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16422}
16423template<>
16424void Hdf5Back::WriteToBuf<PAIR_INT_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16425 std::pair<int, float> val0=a->cast<std::pair<int, float>>();
16426 size_t item_size0=((sizeof(int)+sizeof(float)));
16427 size_t item_size1first=sizeof(int);
16428 size_t item_size1second=sizeof(float);
16429 size_t total_item_size0=item_size1first+item_size1second;
16430 unsigned int count0=0;
16431 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16432 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16433}
16434template<>
16435void Hdf5Back::WriteToBuf<PAIR_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16436 std::pair<int, double> val0=a->cast<std::pair<int, double>>();
16437 size_t item_size0=((sizeof(int)+sizeof(double)));
16438 size_t item_size1first=sizeof(int);
16439 size_t item_size1second=sizeof(double);
16440 size_t total_item_size0=item_size1first+item_size1second;
16441 unsigned int count0=0;
16442 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16443 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16444}
16445template<>
16446void Hdf5Back::WriteToBuf<PAIR_INT_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16447 std::pair<int, std::string> val0=a->cast<std::pair<int, std::string>>();
16448 size_t item_size0=((sizeof(int)+shape[2]));
16449 size_t item_size1first=sizeof(int);
16450 size_t item_size1second=shape[2];
16451 size_t valuelen1second;
16452 size_t total_item_size0=item_size1first+item_size1second;
16453 unsigned int count0=0;
16454 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16455 valuelen1second=std::min(val0.second.size(), item_size1second);
16456 memcpy(buf+(count0*total_item_size0)+0+item_size1first, val0.second.c_str(), valuelen1second);
16457 memset(buf+(count0*total_item_size0)+0+item_size1first+valuelen1second, 0, item_size1second-valuelen1second);
16458}
16459template<>
16460void Hdf5Back::WriteToBuf<PAIR_INT_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16461 std::pair<int, std::string> val0=a->cast<std::pair<int, std::string>>();
16462 size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE));
16463 size_t item_size1first=sizeof(int);
16464 size_t item_size1second=CYCLUS_SHA1_SIZE;
16465 size_t total_item_size0=item_size1first+item_size1second;
16466 unsigned int count0=0;
16467 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16468 hasher_.Clear();
16469 hasher_.Update(val0.second);
16470 Digest key1second = hasher_.digest();
16471 hid_t keysds1second = VLDataset(VL_STRING, true);
16472 hid_t valsds1second = VLDataset(VL_STRING, false);
16473 if (vlkeys_[VL_STRING].count(key1second) != 1) {
16474 AppendVLKey(keysds1second, VL_STRING, key1second);
16475 InsertVLVal(valsds1second, VL_STRING, key1second, val0.second);
16476 }
16477 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
16478}
16479template<>
16480void Hdf5Back::WriteToBuf<PAIR_INT_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16481 std::pair<int, cyclus::Blob> val0=a->cast<std::pair<int, cyclus::Blob>>();
16482 size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE));
16483 size_t item_size1first=sizeof(int);
16484 size_t item_size1second=CYCLUS_SHA1_SIZE;
16485 size_t total_item_size0=item_size1first+item_size1second;
16486 unsigned int count0=0;
16487 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16488 hasher_.Clear();
16489 hasher_.Update(val0.second);
16490 Digest key1second = hasher_.digest();
16491 hid_t keysds1second = VLDataset(BLOB, true);
16492 hid_t valsds1second = VLDataset(BLOB, false);
16493 if (vlkeys_[BLOB].count(key1second) != 1) {
16494 AppendVLKey(keysds1second, BLOB, key1second);
16495 InsertVLVal(valsds1second, BLOB, key1second, (val0.second).str());
16496 }
16497 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
16498}
16499template<>
16500void Hdf5Back::WriteToBuf<PAIR_INT_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16501 std::pair<int, boost::uuids::uuid> val0=a->cast<std::pair<int, boost::uuids::uuid>>();
16502 size_t item_size0=((sizeof(int)+CYCLUS_UUID_SIZE));
16503 size_t item_size1first=sizeof(int);
16504 size_t item_size1second=CYCLUS_UUID_SIZE;
16505 size_t total_item_size0=item_size1first+item_size1second;
16506 unsigned int count0=0;
16507 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16508 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16509}
16510template<>
16511void Hdf5Back::WriteToBuf<PAIR_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16512 std::pair<std::string, bool> val0=a->cast<std::pair<std::string, bool>>();
16513 size_t item_size0=((shape[1]+sizeof(char)));
16514 size_t item_size1first=shape[1];
16515 size_t valuelen1first;
16516 size_t item_size1second=sizeof(char);
16517 size_t total_item_size0=item_size1first+item_size1second;
16518 unsigned int count0=0;
16519 valuelen1first=std::min(val0.first.size(), item_size1first);
16520 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16521 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16522 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16523}
16524template<>
16525void Hdf5Back::WriteToBuf<PAIR_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16526 std::pair<std::string, int> val0=a->cast<std::pair<std::string, int>>();
16527 size_t item_size0=((shape[1]+sizeof(int)));
16528 size_t item_size1first=shape[1];
16529 size_t valuelen1first;
16530 size_t item_size1second=sizeof(int);
16531 size_t total_item_size0=item_size1first+item_size1second;
16532 unsigned int count0=0;
16533 valuelen1first=std::min(val0.first.size(), item_size1first);
16534 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16535 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16536 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16537}
16538template<>
16539void Hdf5Back::WriteToBuf<PAIR_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16540 std::pair<std::string, float> val0=a->cast<std::pair<std::string, float>>();
16541 size_t item_size0=((shape[1]+sizeof(float)));
16542 size_t item_size1first=shape[1];
16543 size_t valuelen1first;
16544 size_t item_size1second=sizeof(float);
16545 size_t total_item_size0=item_size1first+item_size1second;
16546 unsigned int count0=0;
16547 valuelen1first=std::min(val0.first.size(), item_size1first);
16548 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16549 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16550 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16551}
16552template<>
16553void Hdf5Back::WriteToBuf<PAIR_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16554 std::pair<std::string, double> val0=a->cast<std::pair<std::string, double>>();
16555 size_t item_size0=((shape[1]+sizeof(double)));
16556 size_t item_size1first=shape[1];
16557 size_t valuelen1first;
16558 size_t item_size1second=sizeof(double);
16559 size_t total_item_size0=item_size1first+item_size1second;
16560 unsigned int count0=0;
16561 valuelen1first=std::min(val0.first.size(), item_size1first);
16562 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16563 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16564 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16565}
16566template<>
16567void Hdf5Back::WriteToBuf<PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16568 std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16569 size_t item_size0=((shape[1]+shape[2]));
16570 size_t item_size1first=shape[1];
16571 size_t valuelen1first;
16572 size_t item_size1second=shape[2];
16573 size_t valuelen1second;
16574 size_t total_item_size0=item_size1first+item_size1second;
16575 unsigned int count0=0;
16576 valuelen1first=std::min(val0.first.size(), item_size1first);
16577 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16578 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16579 valuelen1second=std::min(val0.second.size(), item_size1second);
16580 memcpy(buf+(count0*total_item_size0)+0+item_size1first, val0.second.c_str(), valuelen1second);
16581 memset(buf+(count0*total_item_size0)+0+item_size1first+valuelen1second, 0, item_size1second-valuelen1second);
16582}
16583template<>
16584void Hdf5Back::WriteToBuf<PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16585 std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16586 size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE));
16587 size_t item_size1first=shape[1];
16588 size_t valuelen1first;
16589 size_t item_size1second=CYCLUS_SHA1_SIZE;
16590 size_t total_item_size0=item_size1first+item_size1second;
16591 unsigned int count0=0;
16592 valuelen1first=std::min(val0.first.size(), item_size1first);
16593 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16594 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16595 hasher_.Clear();
16596 hasher_.Update(val0.second);
16597 Digest key1second = hasher_.digest();
16598 hid_t keysds1second = VLDataset(VL_STRING, true);
16599 hid_t valsds1second = VLDataset(VL_STRING, false);
16600 if (vlkeys_[VL_STRING].count(key1second) != 1) {
16601 AppendVLKey(keysds1second, VL_STRING, key1second);
16602 InsertVLVal(valsds1second, VL_STRING, key1second, val0.second);
16603 }
16604 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
16605}
16606template<>
16607void Hdf5Back::WriteToBuf<PAIR_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16608 std::pair<std::string, cyclus::Blob> val0=a->cast<std::pair<std::string, cyclus::Blob>>();
16609 size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE));
16610 size_t item_size1first=shape[1];
16611 size_t valuelen1first;
16612 size_t item_size1second=CYCLUS_SHA1_SIZE;
16613 size_t total_item_size0=item_size1first+item_size1second;
16614 unsigned int count0=0;
16615 valuelen1first=std::min(val0.first.size(), item_size1first);
16616 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16617 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16618 hasher_.Clear();
16619 hasher_.Update(val0.second);
16620 Digest key1second = hasher_.digest();
16621 hid_t keysds1second = VLDataset(BLOB, true);
16622 hid_t valsds1second = VLDataset(BLOB, false);
16623 if (vlkeys_[BLOB].count(key1second) != 1) {
16624 AppendVLKey(keysds1second, BLOB, key1second);
16625 InsertVLVal(valsds1second, BLOB, key1second, (val0.second).str());
16626 }
16627 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
16628}
16629template<>
16630void Hdf5Back::WriteToBuf<PAIR_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16631 std::pair<std::string, boost::uuids::uuid> val0=a->cast<std::pair<std::string, boost::uuids::uuid>>();
16632 size_t item_size0=((shape[1]+CYCLUS_UUID_SIZE));
16633 size_t item_size1first=shape[1];
16634 size_t valuelen1first;
16635 size_t item_size1second=CYCLUS_UUID_SIZE;
16636 size_t total_item_size0=item_size1first+item_size1second;
16637 unsigned int count0=0;
16638 valuelen1first=std::min(val0.first.size(), item_size1first);
16639 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16640 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16641 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16642}
16643template<>
16644void Hdf5Back::WriteToBuf<PAIR_VL_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16645 std::pair<std::string, bool> val0=a->cast<std::pair<std::string, bool>>();
16646 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(char)));
16647 size_t item_size1first=CYCLUS_SHA1_SIZE;
16648 size_t item_size1second=sizeof(char);
16649 size_t total_item_size0=item_size1first+item_size1second;
16650 unsigned int count0=0;
16651 hasher_.Clear();
16652 hasher_.Update(val0.first);
16653 Digest key1first = hasher_.digest();
16654 hid_t keysds1first = VLDataset(VL_STRING, true);
16655 hid_t valsds1first = VLDataset(VL_STRING, false);
16656 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16657 AppendVLKey(keysds1first, VL_STRING, key1first);
16658 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16659 }
16660 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16661 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16662}
16663template<>
16664void Hdf5Back::WriteToBuf<PAIR_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16665 std::pair<std::string, int> val0=a->cast<std::pair<std::string, int>>();
16666 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(int)));
16667 size_t item_size1first=CYCLUS_SHA1_SIZE;
16668 size_t item_size1second=sizeof(int);
16669 size_t total_item_size0=item_size1first+item_size1second;
16670 unsigned int count0=0;
16671 hasher_.Clear();
16672 hasher_.Update(val0.first);
16673 Digest key1first = hasher_.digest();
16674 hid_t keysds1first = VLDataset(VL_STRING, true);
16675 hid_t valsds1first = VLDataset(VL_STRING, false);
16676 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16677 AppendVLKey(keysds1first, VL_STRING, key1first);
16678 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16679 }
16680 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16681 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16682}
16683template<>
16684void Hdf5Back::WriteToBuf<PAIR_VL_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16685 std::pair<std::string, float> val0=a->cast<std::pair<std::string, float>>();
16686 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(float)));
16687 size_t item_size1first=CYCLUS_SHA1_SIZE;
16688 size_t item_size1second=sizeof(float);
16689 size_t total_item_size0=item_size1first+item_size1second;
16690 unsigned int count0=0;
16691 hasher_.Clear();
16692 hasher_.Update(val0.first);
16693 Digest key1first = hasher_.digest();
16694 hid_t keysds1first = VLDataset(VL_STRING, true);
16695 hid_t valsds1first = VLDataset(VL_STRING, false);
16696 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16697 AppendVLKey(keysds1first, VL_STRING, key1first);
16698 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16699 }
16700 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16701 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16702}
16703template<>
16704void Hdf5Back::WriteToBuf<PAIR_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16705 std::pair<std::string, double> val0=a->cast<std::pair<std::string, double>>();
16706 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(double)));
16707 size_t item_size1first=CYCLUS_SHA1_SIZE;
16708 size_t item_size1second=sizeof(double);
16709 size_t total_item_size0=item_size1first+item_size1second;
16710 unsigned int count0=0;
16711 hasher_.Clear();
16712 hasher_.Update(val0.first);
16713 Digest key1first = hasher_.digest();
16714 hid_t keysds1first = VLDataset(VL_STRING, true);
16715 hid_t valsds1first = VLDataset(VL_STRING, false);
16716 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16717 AppendVLKey(keysds1first, VL_STRING, key1first);
16718 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16719 }
16720 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16721 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16722}
16723template<>
16724void Hdf5Back::WriteToBuf<PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16725 std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16726 size_t item_size0=((CYCLUS_SHA1_SIZE+shape[2]));
16727 size_t item_size1first=CYCLUS_SHA1_SIZE;
16728 size_t item_size1second=shape[2];
16729 size_t valuelen1second;
16730 size_t total_item_size0=item_size1first+item_size1second;
16731 unsigned int count0=0;
16732 hasher_.Clear();
16733 hasher_.Update(val0.first);
16734 Digest key1first = hasher_.digest();
16735 hid_t keysds1first = VLDataset(VL_STRING, true);
16736 hid_t valsds1first = VLDataset(VL_STRING, false);
16737 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16738 AppendVLKey(keysds1first, VL_STRING, key1first);
16739 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16740 }
16741 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16742 valuelen1second=std::min(val0.second.size(), item_size1second);
16743 memcpy(buf+(count0*total_item_size0)+0+item_size1first, val0.second.c_str(), valuelen1second);
16744 memset(buf+(count0*total_item_size0)+0+item_size1first+valuelen1second, 0, item_size1second-valuelen1second);
16745}
16746template<>
16747void Hdf5Back::WriteToBuf<PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16748 std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16749 size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
16750 size_t item_size1first=CYCLUS_SHA1_SIZE;
16751 size_t item_size1second=CYCLUS_SHA1_SIZE;
16752 size_t total_item_size0=item_size1first+item_size1second;
16753 unsigned int count0=0;
16754 hasher_.Clear();
16755 hasher_.Update(val0.first);
16756 Digest key1first = hasher_.digest();
16757 hid_t keysds1first = VLDataset(VL_STRING, true);
16758 hid_t valsds1first = VLDataset(VL_STRING, false);
16759 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16760 AppendVLKey(keysds1first, VL_STRING, key1first);
16761 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16762 }
16763 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16764 hasher_.Clear();
16765 hasher_.Update(val0.second);
16766 Digest key1second = hasher_.digest();
16767 hid_t keysds1second = VLDataset(VL_STRING, true);
16768 hid_t valsds1second = VLDataset(VL_STRING, false);
16769 if (vlkeys_[VL_STRING].count(key1second) != 1) {
16770 AppendVLKey(keysds1second, VL_STRING, key1second);
16771 InsertVLVal(valsds1second, VL_STRING, key1second, val0.second);
16772 }
16773 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
16774}
16775template<>
16776void Hdf5Back::WriteToBuf<PAIR_VL_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16777 std::pair<std::string, cyclus::Blob> val0=a->cast<std::pair<std::string, cyclus::Blob>>();
16778 size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
16779 size_t item_size1first=CYCLUS_SHA1_SIZE;
16780 size_t item_size1second=CYCLUS_SHA1_SIZE;
16781 size_t total_item_size0=item_size1first+item_size1second;
16782 unsigned int count0=0;
16783 hasher_.Clear();
16784 hasher_.Update(val0.first);
16785 Digest key1first = hasher_.digest();
16786 hid_t keysds1first = VLDataset(VL_STRING, true);
16787 hid_t valsds1first = VLDataset(VL_STRING, false);
16788 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16789 AppendVLKey(keysds1first, VL_STRING, key1first);
16790 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16791 }
16792 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16793 hasher_.Clear();
16794 hasher_.Update(val0.second);
16795 Digest key1second = hasher_.digest();
16796 hid_t keysds1second = VLDataset(BLOB, true);
16797 hid_t valsds1second = VLDataset(BLOB, false);
16798 if (vlkeys_[BLOB].count(key1second) != 1) {
16799 AppendVLKey(keysds1second, BLOB, key1second);
16800 InsertVLVal(valsds1second, BLOB, key1second, (val0.second).str());
16801 }
16802 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
16803}
16804template<>
16805void Hdf5Back::WriteToBuf<PAIR_VL_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16806 std::pair<std::string, boost::uuids::uuid> val0=a->cast<std::pair<std::string, boost::uuids::uuid>>();
16807 size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE));
16808 size_t item_size1first=CYCLUS_SHA1_SIZE;
16809 size_t item_size1second=CYCLUS_UUID_SIZE;
16810 size_t total_item_size0=item_size1first+item_size1second;
16811 unsigned int count0=0;
16812 hasher_.Clear();
16813 hasher_.Update(val0.first);
16814 Digest key1first = hasher_.digest();
16815 hid_t keysds1first = VLDataset(VL_STRING, true);
16816 hid_t valsds1first = VLDataset(VL_STRING, false);
16817 if (vlkeys_[VL_STRING].count(key1first) != 1) {
16818 AppendVLKey(keysds1first, VL_STRING, key1first);
16819 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16820 }
16821 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
16822 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16823}
16824template<>
16825void Hdf5Back::WriteToBuf<MAP_INT_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16826 std::map<int, bool> val0=a->cast<std::map<int, bool>>();
16827 size_t item_size0=((sizeof(int)+sizeof(char))*shape[0]);
16828 size_t length0=shape[0];
16829 size_t item_size1key=sizeof(int);
16830 size_t item_size1val=sizeof(char);
16831 size_t total_item_size0=item_size1key+item_size1val;
16832 if(total_item_size0*val0.size()>column){
16833 std::map<int, bool>::iterator eraseit=val0.begin();
16834 std::advance(eraseit, column/total_item_size0);
16835 val0.erase(eraseit,val0.end());
16836
16837 }
16838 unsigned int count0=0;
16839 std::map<int, bool>::iterator it0=val0.begin();
16840 for(;it0!=val0.end();++it0){
16841 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16842 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16843 ++count0;
16844
16845 }
16846 if(total_item_size0*length0<column){
16847 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16848
16849 }
16850}
16851template<>
16852void Hdf5Back::WriteToBuf<VL_MAP_INT_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16853 std::map<int, bool> val0=a->cast<std::map<int, bool>>();
16854 size_t item_size0=(CYCLUS_SHA1_SIZE);
16855 size_t item_size1key=sizeof(int);
16856 size_t item_size1val=sizeof(char);
16857 size_t total_item_size0=item_size1key+item_size1val;
16858 hasher_.Clear();
16859 hasher_.Update(val0);
16860 Digest key0 = hasher_.digest();
16861 hid_t keysds0 = VLDataset(VL_MAP_INT_BOOL, true);
16862 hid_t valsds0 = VLDataset(VL_MAP_INT_BOOL, false);
16863 if (vlkeys_[VL_MAP_INT_BOOL].count(key0) != 1) {
16864 hvl_t buf0 = VLValToBuf(val0);
16865 AppendVLKey(keysds0, VL_MAP_INT_BOOL, key0);
16866 InsertVLVal(valsds0, VL_MAP_INT_BOOL, key0, buf0);
16867 }
16868 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16869}
16870template<>
16871void Hdf5Back::WriteToBuf<MAP_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16872 std::map<int, int> val0=a->cast<std::map<int, int>>();
16873 size_t item_size0=((sizeof(int)+sizeof(int))*shape[0]);
16874 size_t length0=shape[0];
16875 size_t item_size1key=sizeof(int);
16876 size_t item_size1val=sizeof(int);
16877 size_t total_item_size0=item_size1key+item_size1val;
16878 if(total_item_size0*val0.size()>column){
16879 std::map<int, int>::iterator eraseit=val0.begin();
16880 std::advance(eraseit, column/total_item_size0);
16881 val0.erase(eraseit,val0.end());
16882
16883 }
16884 unsigned int count0=0;
16885 std::map<int, int>::iterator it0=val0.begin();
16886 for(;it0!=val0.end();++it0){
16887 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16888 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16889 ++count0;
16890
16891 }
16892 if(total_item_size0*length0<column){
16893 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16894
16895 }
16896}
16897template<>
16898void Hdf5Back::WriteToBuf<VL_MAP_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16899 std::map<int, int> val0=a->cast<std::map<int, int>>();
16900 size_t item_size0=(CYCLUS_SHA1_SIZE);
16901 size_t item_size1key=sizeof(int);
16902 size_t item_size1val=sizeof(int);
16903 size_t total_item_size0=item_size1key+item_size1val;
16904 hasher_.Clear();
16905 hasher_.Update(val0);
16906 Digest key0 = hasher_.digest();
16907 hid_t keysds0 = VLDataset(VL_MAP_INT_INT, true);
16908 hid_t valsds0 = VLDataset(VL_MAP_INT_INT, false);
16909 if (vlkeys_[VL_MAP_INT_INT].count(key0) != 1) {
16910 hvl_t buf0 = VLValToBuf(val0);
16911 AppendVLKey(keysds0, VL_MAP_INT_INT, key0);
16912 InsertVLVal(valsds0, VL_MAP_INT_INT, key0, buf0);
16913 }
16914 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16915}
16916template<>
16917void Hdf5Back::WriteToBuf<MAP_INT_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16918 std::map<int, float> val0=a->cast<std::map<int, float>>();
16919 size_t item_size0=((sizeof(int)+sizeof(float))*shape[0]);
16920 size_t length0=shape[0];
16921 size_t item_size1key=sizeof(int);
16922 size_t item_size1val=sizeof(float);
16923 size_t total_item_size0=item_size1key+item_size1val;
16924 if(total_item_size0*val0.size()>column){
16925 std::map<int, float>::iterator eraseit=val0.begin();
16926 std::advance(eraseit, column/total_item_size0);
16927 val0.erase(eraseit,val0.end());
16928
16929 }
16930 unsigned int count0=0;
16931 std::map<int, float>::iterator it0=val0.begin();
16932 for(;it0!=val0.end();++it0){
16933 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16934 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16935 ++count0;
16936
16937 }
16938 if(total_item_size0*length0<column){
16939 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16940
16941 }
16942}
16943template<>
16944void Hdf5Back::WriteToBuf<VL_MAP_INT_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16945 std::map<int, float> val0=a->cast<std::map<int, float>>();
16946 size_t item_size0=(CYCLUS_SHA1_SIZE);
16947 size_t item_size1key=sizeof(int);
16948 size_t item_size1val=sizeof(float);
16949 size_t total_item_size0=item_size1key+item_size1val;
16950 hasher_.Clear();
16951 hasher_.Update(val0);
16952 Digest key0 = hasher_.digest();
16953 hid_t keysds0 = VLDataset(VL_MAP_INT_FLOAT, true);
16954 hid_t valsds0 = VLDataset(VL_MAP_INT_FLOAT, false);
16955 if (vlkeys_[VL_MAP_INT_FLOAT].count(key0) != 1) {
16956 hvl_t buf0 = VLValToBuf(val0);
16957 AppendVLKey(keysds0, VL_MAP_INT_FLOAT, key0);
16958 InsertVLVal(valsds0, VL_MAP_INT_FLOAT, key0, buf0);
16959 }
16960 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
16961}
16962template<>
16963void Hdf5Back::WriteToBuf<MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16964 std::map<int, double> val0=a->cast<std::map<int, double>>();
16965 size_t item_size0=((sizeof(int)+sizeof(double))*shape[0]);
16966 size_t length0=shape[0];
16967 size_t item_size1key=sizeof(int);
16968 size_t item_size1val=sizeof(double);
16969 size_t total_item_size0=item_size1key+item_size1val;
16970 if(total_item_size0*val0.size()>column){
16971 std::map<int, double>::iterator eraseit=val0.begin();
16972 std::advance(eraseit, column/total_item_size0);
16973 val0.erase(eraseit,val0.end());
16974
16975 }
16976 unsigned int count0=0;
16977 std::map<int, double>::iterator it0=val0.begin();
16978 for(;it0!=val0.end();++it0){
16979 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16980 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16981 ++count0;
16982
16983 }
16984 if(total_item_size0*length0<column){
16985 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16986
16987 }
16988}
16989template<>
16990void Hdf5Back::WriteToBuf<VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16991 std::map<int, double> val0=a->cast<std::map<int, double>>();
16992 size_t item_size0=(CYCLUS_SHA1_SIZE);
16993 size_t item_size1key=sizeof(int);
16994 size_t item_size1val=sizeof(double);
16995 size_t total_item_size0=item_size1key+item_size1val;
16996 hasher_.Clear();
16997 hasher_.Update(val0);
16998 Digest key0 = hasher_.digest();
16999 hid_t keysds0 = VLDataset(VL_MAP_INT_DOUBLE, true);
17000 hid_t valsds0 = VLDataset(VL_MAP_INT_DOUBLE, false);
17001 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key0) != 1) {
17002 hvl_t buf0 = VLValToBuf(val0);
17003 AppendVLKey(keysds0, VL_MAP_INT_DOUBLE, key0);
17004 InsertVLVal(valsds0, VL_MAP_INT_DOUBLE, key0, buf0);
17005 }
17006 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17007}
17008template<>
17009void Hdf5Back::WriteToBuf<MAP_INT_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17010 std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17011 size_t item_size0=((sizeof(int)+shape[2])*shape[0]);
17012 size_t length0=shape[0];
17013 size_t item_size1key=sizeof(int);
17014 size_t item_size1val=shape[2];
17015 size_t valuelen1val;
17016 size_t total_item_size0=item_size1key+item_size1val;
17017 if(total_item_size0*val0.size()>column){
17018 std::map<int, std::string>::iterator eraseit=val0.begin();
17019 std::advance(eraseit, column/total_item_size0);
17020 val0.erase(eraseit,val0.end());
17021
17022 }
17023 unsigned int count0=0;
17024 std::map<int, std::string>::iterator it0=val0.begin();
17025 for(;it0!=val0.end();++it0){
17026 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17027 valuelen1val=std::min(it0->second.size(), item_size1val);
17028 memcpy(buf+(count0*total_item_size0)+0+item_size1key, it0->second.c_str(), valuelen1val);
17029 memset(buf+(count0*total_item_size0)+0+item_size1key+valuelen1val, 0, item_size1val-valuelen1val);
17030 ++count0;
17031
17032 }
17033 if(total_item_size0*length0<column){
17034 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17035
17036 }
17037}
17038template<>
17039void Hdf5Back::WriteToBuf<VL_MAP_INT_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17040 std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17041 size_t item_size0=(CYCLUS_SHA1_SIZE);
17042 size_t item_size1key=sizeof(int);
17043 size_t item_size1val=shape[2];
17044 size_t valuelen1val;
17045 size_t total_item_size0=item_size1key+item_size1val;
17046 unsigned int count0=0;
17047 std::map<int, std::string>::iterator it0=val0.begin();
17048 std::map<int, std::string> fixed_val0;
17049 unsigned int pad_count0=0;
17050 for(;it0!=val0.end();++it0){
17051 std::string child1val=std::string(it0->second,0,item_size1val);
17052 fixed_val0[it0->first] = child1val;
17053 ++pad_count0;
17054
17055 }
17056 hasher_.Clear();
17057 hasher_.Update(fixed_val0);
17058 Digest key0 = hasher_.digest();
17059 hid_t keysds0 = VLDataset(VL_MAP_INT_STRING, true);
17060 hid_t valsds0 = VLDataset(VL_MAP_INT_STRING, false);
17061 if (vlkeys_[VL_MAP_INT_STRING].count(key0) != 1) {
17062 hvl_t buf0 = VLValToBuf(fixed_val0);
17063 AppendVLKey(keysds0, VL_MAP_INT_STRING, key0);
17064 InsertVLVal(valsds0, VL_MAP_INT_STRING, key0, buf0);
17065 }
17066 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17067}
17068template<>
17069void Hdf5Back::WriteToBuf<MAP_INT_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17070 std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17071 size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
17072 size_t length0=shape[0];
17073 size_t item_size1key=sizeof(int);
17074 size_t item_size1val=CYCLUS_SHA1_SIZE;
17075 size_t total_item_size0=item_size1key+item_size1val;
17076 if(total_item_size0*val0.size()>column){
17077 std::map<int, std::string>::iterator eraseit=val0.begin();
17078 std::advance(eraseit, column/total_item_size0);
17079 val0.erase(eraseit,val0.end());
17080
17081 }
17082 unsigned int count0=0;
17083 std::map<int, std::string>::iterator it0=val0.begin();
17084 for(;it0!=val0.end();++it0){
17085 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17086 hasher_.Clear();
17087 hasher_.Update(it0->second);
17088 Digest key1val = hasher_.digest();
17089 hid_t keysds1val = VLDataset(VL_STRING, true);
17090 hid_t valsds1val = VLDataset(VL_STRING, false);
17091 if (vlkeys_[VL_STRING].count(key1val) != 1) {
17092 AppendVLKey(keysds1val, VL_STRING, key1val);
17093 InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
17094 }
17095 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
17096 ++count0;
17097
17098 }
17099 if(total_item_size0*length0<column){
17100 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17101
17102 }
17103}
17104template<>
17105void Hdf5Back::WriteToBuf<VL_MAP_INT_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17106 std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17107 size_t item_size0=(CYCLUS_SHA1_SIZE);
17108 size_t item_size1key=sizeof(int);
17109 size_t item_size1val=CYCLUS_SHA1_SIZE;
17110 size_t total_item_size0=item_size1key+item_size1val;
17111 hasher_.Clear();
17112 hasher_.Update(val0);
17113 Digest key0 = hasher_.digest();
17114 hid_t keysds0 = VLDataset(VL_MAP_INT_VL_STRING, true);
17115 hid_t valsds0 = VLDataset(VL_MAP_INT_VL_STRING, false);
17116 if (vlkeys_[VL_MAP_INT_VL_STRING].count(key0) != 1) {
17117 hvl_t buf0 = VLValToBuf(val0);
17118 AppendVLKey(keysds0, VL_MAP_INT_VL_STRING, key0);
17119 InsertVLVal(valsds0, VL_MAP_INT_VL_STRING, key0, buf0);
17120 }
17121 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17122}
17123template<>
17124void Hdf5Back::WriteToBuf<MAP_INT_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17125 std::map<int, cyclus::Blob> val0=a->cast<std::map<int, cyclus::Blob>>();
17126 size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
17127 size_t length0=shape[0];
17128 size_t item_size1key=sizeof(int);
17129 size_t item_size1val=CYCLUS_SHA1_SIZE;
17130 size_t total_item_size0=item_size1key+item_size1val;
17131 if(total_item_size0*val0.size()>column){
17132 std::map<int, cyclus::Blob>::iterator eraseit=val0.begin();
17133 std::advance(eraseit, column/total_item_size0);
17134 val0.erase(eraseit,val0.end());
17135
17136 }
17137 unsigned int count0=0;
17138 std::map<int, cyclus::Blob>::iterator it0=val0.begin();
17139 for(;it0!=val0.end();++it0){
17140 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17141 hasher_.Clear();
17142 hasher_.Update(it0->second);
17143 Digest key1val = hasher_.digest();
17144 hid_t keysds1val = VLDataset(BLOB, true);
17145 hid_t valsds1val = VLDataset(BLOB, false);
17146 if (vlkeys_[BLOB].count(key1val) != 1) {
17147 AppendVLKey(keysds1val, BLOB, key1val);
17148 InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
17149 }
17150 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
17151 ++count0;
17152
17153 }
17154 if(total_item_size0*length0<column){
17155 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17156
17157 }
17158}
17159template<>
17160void Hdf5Back::WriteToBuf<VL_MAP_INT_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17161 std::map<int, cyclus::Blob> val0=a->cast<std::map<int, cyclus::Blob>>();
17162 size_t item_size0=(CYCLUS_SHA1_SIZE);
17163 size_t item_size1key=sizeof(int);
17164 size_t item_size1val=CYCLUS_SHA1_SIZE;
17165 size_t total_item_size0=item_size1key+item_size1val;
17166 hasher_.Clear();
17167 hasher_.Update(val0);
17168 Digest key0 = hasher_.digest();
17169 hid_t keysds0 = VLDataset(VL_MAP_INT_BLOB, true);
17170 hid_t valsds0 = VLDataset(VL_MAP_INT_BLOB, false);
17171 if (vlkeys_[VL_MAP_INT_BLOB].count(key0) != 1) {
17172 hvl_t buf0 = VLValToBuf(val0);
17173 AppendVLKey(keysds0, VL_MAP_INT_BLOB, key0);
17174 InsertVLVal(valsds0, VL_MAP_INT_BLOB, key0, buf0);
17175 }
17176 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17177}
17178template<>
17179void Hdf5Back::WriteToBuf<MAP_INT_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17180 std::map<int, boost::uuids::uuid> val0=a->cast<std::map<int, boost::uuids::uuid>>();
17181 size_t item_size0=((sizeof(int)+CYCLUS_UUID_SIZE)*shape[0]);
17182 size_t length0=shape[0];
17183 size_t item_size1key=sizeof(int);
17184 size_t item_size1val=CYCLUS_UUID_SIZE;
17185 size_t total_item_size0=item_size1key+item_size1val;
17186 if(total_item_size0*val0.size()>column){
17187 std::map<int, boost::uuids::uuid>::iterator eraseit=val0.begin();
17188 std::advance(eraseit, column/total_item_size0);
17189 val0.erase(eraseit,val0.end());
17190
17191 }
17192 unsigned int count0=0;
17193 std::map<int, boost::uuids::uuid>::iterator it0=val0.begin();
17194 for(;it0!=val0.end();++it0){
17195 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17196 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17197 ++count0;
17198
17199 }
17200 if(total_item_size0*length0<column){
17201 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17202
17203 }
17204}
17205template<>
17206void Hdf5Back::WriteToBuf<VL_MAP_INT_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17207 std::map<int, boost::uuids::uuid> val0=a->cast<std::map<int, boost::uuids::uuid>>();
17208 size_t item_size0=(CYCLUS_SHA1_SIZE);
17209 size_t item_size1key=sizeof(int);
17210 size_t item_size1val=CYCLUS_UUID_SIZE;
17211 size_t total_item_size0=item_size1key+item_size1val;
17212 hasher_.Clear();
17213 hasher_.Update(val0);
17214 Digest key0 = hasher_.digest();
17215 hid_t keysds0 = VLDataset(VL_MAP_INT_UUID, true);
17216 hid_t valsds0 = VLDataset(VL_MAP_INT_UUID, false);
17217 if (vlkeys_[VL_MAP_INT_UUID].count(key0) != 1) {
17218 hvl_t buf0 = VLValToBuf(val0);
17219 AppendVLKey(keysds0, VL_MAP_INT_UUID, key0);
17220 InsertVLVal(valsds0, VL_MAP_INT_UUID, key0, buf0);
17221 }
17222 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17223}
17224template<>
17225void Hdf5Back::WriteToBuf<MAP_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17226 std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17227 size_t item_size0=((shape[1]+sizeof(char))*shape[0]);
17228 size_t length0=shape[0];
17229 size_t item_size1key=shape[1];
17230 size_t valuelen1key;
17231 size_t item_size1val=sizeof(char);
17232 size_t total_item_size0=item_size1key+item_size1val;
17233 if(total_item_size0*val0.size()>column){
17234 std::map<std::string, bool>::iterator eraseit=val0.begin();
17235 std::advance(eraseit, column/total_item_size0);
17236 val0.erase(eraseit,val0.end());
17237
17238 }
17239 unsigned int count0=0;
17240 std::map<std::string, bool>::iterator it0=val0.begin();
17241 for(;it0!=val0.end();++it0){
17242 valuelen1key=std::min(it0->first.size(), item_size1key);
17243 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17244 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17245 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17246 ++count0;
17247
17248 }
17249 if(total_item_size0*length0<column){
17250 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17251
17252 }
17253}
17254template<>
17255void Hdf5Back::WriteToBuf<VL_MAP_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17256 std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17257 size_t item_size0=(CYCLUS_SHA1_SIZE);
17258 size_t item_size1key=shape[1];
17259 size_t valuelen1key;
17260 size_t item_size1val=sizeof(char);
17261 size_t total_item_size0=item_size1key+item_size1val;
17262 unsigned int count0=0;
17263 std::map<std::string, bool>::iterator it0=val0.begin();
17264 std::map<std::string, bool> fixed_val0;
17265 unsigned int pad_count0=0;
17266 for(;it0!=val0.end();++it0){
17267 std::string child1key=std::string(it0->first,0,item_size1key);
17268 fixed_val0[child1key] = it0->second;
17269 ++pad_count0;
17270
17271 }
17272 hasher_.Clear();
17273 hasher_.Update(fixed_val0);
17274 Digest key0 = hasher_.digest();
17275 hid_t keysds0 = VLDataset(VL_MAP_STRING_BOOL, true);
17276 hid_t valsds0 = VLDataset(VL_MAP_STRING_BOOL, false);
17277 if (vlkeys_[VL_MAP_STRING_BOOL].count(key0) != 1) {
17278 hvl_t buf0 = VLValToBuf(fixed_val0);
17279 AppendVLKey(keysds0, VL_MAP_STRING_BOOL, key0);
17280 InsertVLVal(valsds0, VL_MAP_STRING_BOOL, key0, buf0);
17281 }
17282 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17283}
17284template<>
17285void Hdf5Back::WriteToBuf<MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17286 std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17287 size_t item_size0=((shape[1]+sizeof(int))*shape[0]);
17288 size_t length0=shape[0];
17289 size_t item_size1key=shape[1];
17290 size_t valuelen1key;
17291 size_t item_size1val=sizeof(int);
17292 size_t total_item_size0=item_size1key+item_size1val;
17293 if(total_item_size0*val0.size()>column){
17294 std::map<std::string, int>::iterator eraseit=val0.begin();
17295 std::advance(eraseit, column/total_item_size0);
17296 val0.erase(eraseit,val0.end());
17297
17298 }
17299 unsigned int count0=0;
17300 std::map<std::string, int>::iterator it0=val0.begin();
17301 for(;it0!=val0.end();++it0){
17302 valuelen1key=std::min(it0->first.size(), item_size1key);
17303 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17304 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17305 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17306 ++count0;
17307
17308 }
17309 if(total_item_size0*length0<column){
17310 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17311
17312 }
17313}
17314template<>
17315void Hdf5Back::WriteToBuf<VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17316 std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17317 size_t item_size0=(CYCLUS_SHA1_SIZE);
17318 size_t item_size1key=shape[1];
17319 size_t valuelen1key;
17320 size_t item_size1val=sizeof(int);
17321 size_t total_item_size0=item_size1key+item_size1val;
17322 unsigned int count0=0;
17323 std::map<std::string, int>::iterator it0=val0.begin();
17324 std::map<std::string, int> fixed_val0;
17325 unsigned int pad_count0=0;
17326 for(;it0!=val0.end();++it0){
17327 std::string child1key=std::string(it0->first,0,item_size1key);
17328 fixed_val0[child1key] = it0->second;
17329 ++pad_count0;
17330
17331 }
17332 hasher_.Clear();
17333 hasher_.Update(fixed_val0);
17334 Digest key0 = hasher_.digest();
17335 hid_t keysds0 = VLDataset(VL_MAP_STRING_INT, true);
17336 hid_t valsds0 = VLDataset(VL_MAP_STRING_INT, false);
17337 if (vlkeys_[VL_MAP_STRING_INT].count(key0) != 1) {
17338 hvl_t buf0 = VLValToBuf(fixed_val0);
17339 AppendVLKey(keysds0, VL_MAP_STRING_INT, key0);
17340 InsertVLVal(valsds0, VL_MAP_STRING_INT, key0, buf0);
17341 }
17342 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17343}
17344template<>
17345void Hdf5Back::WriteToBuf<MAP_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17346 std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17347 size_t item_size0=((shape[1]+sizeof(float))*shape[0]);
17348 size_t length0=shape[0];
17349 size_t item_size1key=shape[1];
17350 size_t valuelen1key;
17351 size_t item_size1val=sizeof(float);
17352 size_t total_item_size0=item_size1key+item_size1val;
17353 if(total_item_size0*val0.size()>column){
17354 std::map<std::string, float>::iterator eraseit=val0.begin();
17355 std::advance(eraseit, column/total_item_size0);
17356 val0.erase(eraseit,val0.end());
17357
17358 }
17359 unsigned int count0=0;
17360 std::map<std::string, float>::iterator it0=val0.begin();
17361 for(;it0!=val0.end();++it0){
17362 valuelen1key=std::min(it0->first.size(), item_size1key);
17363 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17364 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17365 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17366 ++count0;
17367
17368 }
17369 if(total_item_size0*length0<column){
17370 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17371
17372 }
17373}
17374template<>
17375void Hdf5Back::WriteToBuf<VL_MAP_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17376 std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17377 size_t item_size0=(CYCLUS_SHA1_SIZE);
17378 size_t item_size1key=shape[1];
17379 size_t valuelen1key;
17380 size_t item_size1val=sizeof(float);
17381 size_t total_item_size0=item_size1key+item_size1val;
17382 unsigned int count0=0;
17383 std::map<std::string, float>::iterator it0=val0.begin();
17384 std::map<std::string, float> fixed_val0;
17385 unsigned int pad_count0=0;
17386 for(;it0!=val0.end();++it0){
17387 std::string child1key=std::string(it0->first,0,item_size1key);
17388 fixed_val0[child1key] = it0->second;
17389 ++pad_count0;
17390
17391 }
17392 hasher_.Clear();
17393 hasher_.Update(fixed_val0);
17394 Digest key0 = hasher_.digest();
17395 hid_t keysds0 = VLDataset(VL_MAP_STRING_FLOAT, true);
17396 hid_t valsds0 = VLDataset(VL_MAP_STRING_FLOAT, false);
17397 if (vlkeys_[VL_MAP_STRING_FLOAT].count(key0) != 1) {
17398 hvl_t buf0 = VLValToBuf(fixed_val0);
17399 AppendVLKey(keysds0, VL_MAP_STRING_FLOAT, key0);
17400 InsertVLVal(valsds0, VL_MAP_STRING_FLOAT, key0, buf0);
17401 }
17402 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17403}
17404template<>
17405void Hdf5Back::WriteToBuf<MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17406 std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17407 size_t item_size0=((shape[1]+sizeof(double))*shape[0]);
17408 size_t length0=shape[0];
17409 size_t item_size1key=shape[1];
17410 size_t valuelen1key;
17411 size_t item_size1val=sizeof(double);
17412 size_t total_item_size0=item_size1key+item_size1val;
17413 if(total_item_size0*val0.size()>column){
17414 std::map<std::string, double>::iterator eraseit=val0.begin();
17415 std::advance(eraseit, column/total_item_size0);
17416 val0.erase(eraseit,val0.end());
17417
17418 }
17419 unsigned int count0=0;
17420 std::map<std::string, double>::iterator it0=val0.begin();
17421 for(;it0!=val0.end();++it0){
17422 valuelen1key=std::min(it0->first.size(), item_size1key);
17423 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17424 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17425 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17426 ++count0;
17427
17428 }
17429 if(total_item_size0*length0<column){
17430 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17431
17432 }
17433}
17434template<>
17435void Hdf5Back::WriteToBuf<VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17436 std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17437 size_t item_size0=(CYCLUS_SHA1_SIZE);
17438 size_t item_size1key=shape[1];
17439 size_t valuelen1key;
17440 size_t item_size1val=sizeof(double);
17441 size_t total_item_size0=item_size1key+item_size1val;
17442 unsigned int count0=0;
17443 std::map<std::string, double>::iterator it0=val0.begin();
17444 std::map<std::string, double> fixed_val0;
17445 unsigned int pad_count0=0;
17446 for(;it0!=val0.end();++it0){
17447 std::string child1key=std::string(it0->first,0,item_size1key);
17448 fixed_val0[child1key] = it0->second;
17449 ++pad_count0;
17450
17451 }
17452 hasher_.Clear();
17453 hasher_.Update(fixed_val0);
17454 Digest key0 = hasher_.digest();
17455 hid_t keysds0 = VLDataset(VL_MAP_STRING_DOUBLE, true);
17456 hid_t valsds0 = VLDataset(VL_MAP_STRING_DOUBLE, false);
17457 if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key0) != 1) {
17458 hvl_t buf0 = VLValToBuf(fixed_val0);
17459 AppendVLKey(keysds0, VL_MAP_STRING_DOUBLE, key0);
17460 InsertVLVal(valsds0, VL_MAP_STRING_DOUBLE, key0, buf0);
17461 }
17462 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17463}
17464template<>
17465void Hdf5Back::WriteToBuf<MAP_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17466 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17467 size_t item_size0=((shape[1]+shape[2])*shape[0]);
17468 size_t length0=shape[0];
17469 size_t item_size1key=shape[1];
17470 size_t valuelen1key;
17471 size_t item_size1val=shape[2];
17472 size_t valuelen1val;
17473 size_t total_item_size0=item_size1key+item_size1val;
17474 if(total_item_size0*val0.size()>column){
17475 std::map<std::string, std::string>::iterator eraseit=val0.begin();
17476 std::advance(eraseit, column/total_item_size0);
17477 val0.erase(eraseit,val0.end());
17478
17479 }
17480 unsigned int count0=0;
17481 std::map<std::string, std::string>::iterator it0=val0.begin();
17482 for(;it0!=val0.end();++it0){
17483 valuelen1key=std::min(it0->first.size(), item_size1key);
17484 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17485 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17486 valuelen1val=std::min(it0->second.size(), item_size1val);
17487 memcpy(buf+(count0*total_item_size0)+0+item_size1key, it0->second.c_str(), valuelen1val);
17488 memset(buf+(count0*total_item_size0)+0+item_size1key+valuelen1val, 0, item_size1val-valuelen1val);
17489 ++count0;
17490
17491 }
17492 if(total_item_size0*length0<column){
17493 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17494
17495 }
17496}
17497template<>
17498void Hdf5Back::WriteToBuf<VL_MAP_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17499 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17500 size_t item_size0=(CYCLUS_SHA1_SIZE);
17501 size_t item_size1key=shape[1];
17502 size_t valuelen1key;
17503 size_t item_size1val=shape[2];
17504 size_t valuelen1val;
17505 size_t total_item_size0=item_size1key+item_size1val;
17506 unsigned int count0=0;
17507 std::map<std::string, std::string>::iterator it0=val0.begin();
17508 std::map<std::string, std::string> fixed_val0;
17509 unsigned int pad_count0=0;
17510 for(;it0!=val0.end();++it0){
17511 std::string child1key=std::string(it0->first,0,item_size1key);
17512 std::string child1val=std::string(it0->second,0,item_size1val);
17513 fixed_val0[child1key] = child1val;
17514 ++pad_count0;
17515
17516 }
17517 hasher_.Clear();
17518 hasher_.Update(fixed_val0);
17519 Digest key0 = hasher_.digest();
17520 hid_t keysds0 = VLDataset(VL_MAP_STRING_STRING, true);
17521 hid_t valsds0 = VLDataset(VL_MAP_STRING_STRING, false);
17522 if (vlkeys_[VL_MAP_STRING_STRING].count(key0) != 1) {
17523 hvl_t buf0 = VLValToBuf(fixed_val0);
17524 AppendVLKey(keysds0, VL_MAP_STRING_STRING, key0);
17525 InsertVLVal(valsds0, VL_MAP_STRING_STRING, key0, buf0);
17526 }
17527 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17528}
17529template<>
17530void Hdf5Back::WriteToBuf<MAP_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17531 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17532 size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
17533 size_t length0=shape[0];
17534 size_t item_size1key=shape[1];
17535 size_t valuelen1key;
17536 size_t item_size1val=CYCLUS_SHA1_SIZE;
17537 size_t total_item_size0=item_size1key+item_size1val;
17538 if(total_item_size0*val0.size()>column){
17539 std::map<std::string, std::string>::iterator eraseit=val0.begin();
17540 std::advance(eraseit, column/total_item_size0);
17541 val0.erase(eraseit,val0.end());
17542
17543 }
17544 unsigned int count0=0;
17545 std::map<std::string, std::string>::iterator it0=val0.begin();
17546 for(;it0!=val0.end();++it0){
17547 valuelen1key=std::min(it0->first.size(), item_size1key);
17548 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17549 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17550 hasher_.Clear();
17551 hasher_.Update(it0->second);
17552 Digest key1val = hasher_.digest();
17553 hid_t keysds1val = VLDataset(VL_STRING, true);
17554 hid_t valsds1val = VLDataset(VL_STRING, false);
17555 if (vlkeys_[VL_STRING].count(key1val) != 1) {
17556 AppendVLKey(keysds1val, VL_STRING, key1val);
17557 InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
17558 }
17559 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
17560 ++count0;
17561
17562 }
17563 if(total_item_size0*length0<column){
17564 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17565
17566 }
17567}
17568template<>
17569void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17570 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17571 size_t item_size0=(CYCLUS_SHA1_SIZE);
17572 size_t item_size1key=shape[1];
17573 size_t valuelen1key;
17574 size_t item_size1val=CYCLUS_SHA1_SIZE;
17575 size_t total_item_size0=item_size1key+item_size1val;
17576 unsigned int count0=0;
17577 std::map<std::string, std::string>::iterator it0=val0.begin();
17578 std::map<std::string, std::string> fixed_val0;
17579 unsigned int pad_count0=0;
17580 for(;it0!=val0.end();++it0){
17581 std::string child1key=std::string(it0->first,0,item_size1key);
17582 fixed_val0[child1key] = it0->second;
17583 ++pad_count0;
17584
17585 }
17586 hasher_.Clear();
17587 hasher_.Update(fixed_val0);
17588 Digest key0 = hasher_.digest();
17589 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_STRING, true);
17590 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_STRING, false);
17591 if (vlkeys_[VL_MAP_STRING_VL_STRING].count(key0) != 1) {
17592 hvl_t buf0 = VLValToBuf(fixed_val0);
17593 AppendVLKey(keysds0, VL_MAP_STRING_VL_STRING, key0);
17594 InsertVLVal(valsds0, VL_MAP_STRING_VL_STRING, key0, buf0);
17595 }
17596 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17597}
17598template<>
17599void Hdf5Back::WriteToBuf<MAP_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17600 std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
17601 size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
17602 size_t length0=shape[0];
17603 size_t item_size1key=shape[1];
17604 size_t valuelen1key;
17605 size_t item_size1val=CYCLUS_SHA1_SIZE;
17606 size_t total_item_size0=item_size1key+item_size1val;
17607 if(total_item_size0*val0.size()>column){
17608 std::map<std::string, cyclus::Blob>::iterator eraseit=val0.begin();
17609 std::advance(eraseit, column/total_item_size0);
17610 val0.erase(eraseit,val0.end());
17611
17612 }
17613 unsigned int count0=0;
17614 std::map<std::string, cyclus::Blob>::iterator it0=val0.begin();
17615 for(;it0!=val0.end();++it0){
17616 valuelen1key=std::min(it0->first.size(), item_size1key);
17617 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17618 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17619 hasher_.Clear();
17620 hasher_.Update(it0->second);
17621 Digest key1val = hasher_.digest();
17622 hid_t keysds1val = VLDataset(BLOB, true);
17623 hid_t valsds1val = VLDataset(BLOB, false);
17624 if (vlkeys_[BLOB].count(key1val) != 1) {
17625 AppendVLKey(keysds1val, BLOB, key1val);
17626 InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
17627 }
17628 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
17629 ++count0;
17630
17631 }
17632 if(total_item_size0*length0<column){
17633 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17634
17635 }
17636}
17637template<>
17638void Hdf5Back::WriteToBuf<VL_MAP_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17639 std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
17640 size_t item_size0=(CYCLUS_SHA1_SIZE);
17641 size_t item_size1key=shape[1];
17642 size_t valuelen1key;
17643 size_t item_size1val=CYCLUS_SHA1_SIZE;
17644 size_t total_item_size0=item_size1key+item_size1val;
17645 unsigned int count0=0;
17646 std::map<std::string, cyclus::Blob>::iterator it0=val0.begin();
17647 std::map<std::string, cyclus::Blob> fixed_val0;
17648 unsigned int pad_count0=0;
17649 for(;it0!=val0.end();++it0){
17650 std::string child1key=std::string(it0->first,0,item_size1key);
17651 fixed_val0[child1key] = it0->second;
17652 ++pad_count0;
17653
17654 }
17655 hasher_.Clear();
17656 hasher_.Update(fixed_val0);
17657 Digest key0 = hasher_.digest();
17658 hid_t keysds0 = VLDataset(VL_MAP_STRING_BLOB, true);
17659 hid_t valsds0 = VLDataset(VL_MAP_STRING_BLOB, false);
17660 if (vlkeys_[VL_MAP_STRING_BLOB].count(key0) != 1) {
17661 hvl_t buf0 = VLValToBuf(fixed_val0);
17662 AppendVLKey(keysds0, VL_MAP_STRING_BLOB, key0);
17663 InsertVLVal(valsds0, VL_MAP_STRING_BLOB, key0, buf0);
17664 }
17665 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17666}
17667template<>
17668void Hdf5Back::WriteToBuf<MAP_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17669 std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
17670 size_t item_size0=((shape[1]+CYCLUS_UUID_SIZE)*shape[0]);
17671 size_t length0=shape[0];
17672 size_t item_size1key=shape[1];
17673 size_t valuelen1key;
17674 size_t item_size1val=CYCLUS_UUID_SIZE;
17675 size_t total_item_size0=item_size1key+item_size1val;
17676 if(total_item_size0*val0.size()>column){
17677 std::map<std::string, boost::uuids::uuid>::iterator eraseit=val0.begin();
17678 std::advance(eraseit, column/total_item_size0);
17679 val0.erase(eraseit,val0.end());
17680
17681 }
17682 unsigned int count0=0;
17683 std::map<std::string, boost::uuids::uuid>::iterator it0=val0.begin();
17684 for(;it0!=val0.end();++it0){
17685 valuelen1key=std::min(it0->first.size(), item_size1key);
17686 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17687 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17688 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17689 ++count0;
17690
17691 }
17692 if(total_item_size0*length0<column){
17693 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17694
17695 }
17696}
17697template<>
17698void Hdf5Back::WriteToBuf<VL_MAP_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17699 std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
17700 size_t item_size0=(CYCLUS_SHA1_SIZE);
17701 size_t item_size1key=shape[1];
17702 size_t valuelen1key;
17703 size_t item_size1val=CYCLUS_UUID_SIZE;
17704 size_t total_item_size0=item_size1key+item_size1val;
17705 unsigned int count0=0;
17706 std::map<std::string, boost::uuids::uuid>::iterator it0=val0.begin();
17707 std::map<std::string, boost::uuids::uuid> fixed_val0;
17708 unsigned int pad_count0=0;
17709 for(;it0!=val0.end();++it0){
17710 std::string child1key=std::string(it0->first,0,item_size1key);
17711 fixed_val0[child1key] = it0->second;
17712 ++pad_count0;
17713
17714 }
17715 hasher_.Clear();
17716 hasher_.Update(fixed_val0);
17717 Digest key0 = hasher_.digest();
17718 hid_t keysds0 = VLDataset(VL_MAP_STRING_UUID, true);
17719 hid_t valsds0 = VLDataset(VL_MAP_STRING_UUID, false);
17720 if (vlkeys_[VL_MAP_STRING_UUID].count(key0) != 1) {
17721 hvl_t buf0 = VLValToBuf(fixed_val0);
17722 AppendVLKey(keysds0, VL_MAP_STRING_UUID, key0);
17723 InsertVLVal(valsds0, VL_MAP_STRING_UUID, key0, buf0);
17724 }
17725 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17726}
17727template<>
17728void Hdf5Back::WriteToBuf<MAP_VL_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17729 std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17730 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(char))*shape[0]);
17731 size_t length0=shape[0];
17732 size_t item_size1key=CYCLUS_SHA1_SIZE;
17733 size_t item_size1val=sizeof(char);
17734 size_t total_item_size0=item_size1key+item_size1val;
17735 if(total_item_size0*val0.size()>column){
17736 std::map<std::string, bool>::iterator eraseit=val0.begin();
17737 std::advance(eraseit, column/total_item_size0);
17738 val0.erase(eraseit,val0.end());
17739
17740 }
17741 unsigned int count0=0;
17742 std::map<std::string, bool>::iterator it0=val0.begin();
17743 for(;it0!=val0.end();++it0){
17744 hasher_.Clear();
17745 hasher_.Update(it0->first);
17746 Digest key1key = hasher_.digest();
17747 hid_t keysds1key = VLDataset(VL_STRING, true);
17748 hid_t valsds1key = VLDataset(VL_STRING, false);
17749 if (vlkeys_[VL_STRING].count(key1key) != 1) {
17750 AppendVLKey(keysds1key, VL_STRING, key1key);
17751 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17752 }
17753 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
17754 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17755 ++count0;
17756
17757 }
17758 if(total_item_size0*length0<column){
17759 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17760
17761 }
17762}
17763template<>
17764void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17765 std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17766 size_t item_size0=(CYCLUS_SHA1_SIZE);
17767 size_t item_size1key=CYCLUS_SHA1_SIZE;
17768 size_t item_size1val=sizeof(char);
17769 size_t total_item_size0=item_size1key+item_size1val;
17770 hasher_.Clear();
17771 hasher_.Update(val0);
17772 Digest key0 = hasher_.digest();
17773 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_BOOL, true);
17774 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_BOOL, false);
17775 if (vlkeys_[VL_MAP_VL_STRING_BOOL].count(key0) != 1) {
17776 hvl_t buf0 = VLValToBuf(val0);
17777 AppendVLKey(keysds0, VL_MAP_VL_STRING_BOOL, key0);
17778 InsertVLVal(valsds0, VL_MAP_VL_STRING_BOOL, key0, buf0);
17779 }
17780 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17781}
17782template<>
17783void Hdf5Back::WriteToBuf<MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17784 std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17785 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[0]);
17786 size_t length0=shape[0];
17787 size_t item_size1key=CYCLUS_SHA1_SIZE;
17788 size_t item_size1val=sizeof(int);
17789 size_t total_item_size0=item_size1key+item_size1val;
17790 if(total_item_size0*val0.size()>column){
17791 std::map<std::string, int>::iterator eraseit=val0.begin();
17792 std::advance(eraseit, column/total_item_size0);
17793 val0.erase(eraseit,val0.end());
17794
17795 }
17796 unsigned int count0=0;
17797 std::map<std::string, int>::iterator it0=val0.begin();
17798 for(;it0!=val0.end();++it0){
17799 hasher_.Clear();
17800 hasher_.Update(it0->first);
17801 Digest key1key = hasher_.digest();
17802 hid_t keysds1key = VLDataset(VL_STRING, true);
17803 hid_t valsds1key = VLDataset(VL_STRING, false);
17804 if (vlkeys_[VL_STRING].count(key1key) != 1) {
17805 AppendVLKey(keysds1key, VL_STRING, key1key);
17806 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17807 }
17808 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
17809 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17810 ++count0;
17811
17812 }
17813 if(total_item_size0*length0<column){
17814 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17815
17816 }
17817}
17818template<>
17819void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17820 std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17821 size_t item_size0=(CYCLUS_SHA1_SIZE);
17822 size_t item_size1key=CYCLUS_SHA1_SIZE;
17823 size_t item_size1val=sizeof(int);
17824 size_t total_item_size0=item_size1key+item_size1val;
17825 hasher_.Clear();
17826 hasher_.Update(val0);
17827 Digest key0 = hasher_.digest();
17828 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_INT, true);
17829 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_INT, false);
17830 if (vlkeys_[VL_MAP_VL_STRING_INT].count(key0) != 1) {
17831 hvl_t buf0 = VLValToBuf(val0);
17832 AppendVLKey(keysds0, VL_MAP_VL_STRING_INT, key0);
17833 InsertVLVal(valsds0, VL_MAP_VL_STRING_INT, key0, buf0);
17834 }
17835 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17836}
17837template<>
17838void Hdf5Back::WriteToBuf<MAP_VL_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17839 std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17840 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(float))*shape[0]);
17841 size_t length0=shape[0];
17842 size_t item_size1key=CYCLUS_SHA1_SIZE;
17843 size_t item_size1val=sizeof(float);
17844 size_t total_item_size0=item_size1key+item_size1val;
17845 if(total_item_size0*val0.size()>column){
17846 std::map<std::string, float>::iterator eraseit=val0.begin();
17847 std::advance(eraseit, column/total_item_size0);
17848 val0.erase(eraseit,val0.end());
17849
17850 }
17851 unsigned int count0=0;
17852 std::map<std::string, float>::iterator it0=val0.begin();
17853 for(;it0!=val0.end();++it0){
17854 hasher_.Clear();
17855 hasher_.Update(it0->first);
17856 Digest key1key = hasher_.digest();
17857 hid_t keysds1key = VLDataset(VL_STRING, true);
17858 hid_t valsds1key = VLDataset(VL_STRING, false);
17859 if (vlkeys_[VL_STRING].count(key1key) != 1) {
17860 AppendVLKey(keysds1key, VL_STRING, key1key);
17861 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17862 }
17863 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
17864 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17865 ++count0;
17866
17867 }
17868 if(total_item_size0*length0<column){
17869 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17870
17871 }
17872}
17873template<>
17874void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17875 std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17876 size_t item_size0=(CYCLUS_SHA1_SIZE);
17877 size_t item_size1key=CYCLUS_SHA1_SIZE;
17878 size_t item_size1val=sizeof(float);
17879 size_t total_item_size0=item_size1key+item_size1val;
17880 hasher_.Clear();
17881 hasher_.Update(val0);
17882 Digest key0 = hasher_.digest();
17883 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_FLOAT, true);
17884 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_FLOAT, false);
17885 if (vlkeys_[VL_MAP_VL_STRING_FLOAT].count(key0) != 1) {
17886 hvl_t buf0 = VLValToBuf(val0);
17887 AppendVLKey(keysds0, VL_MAP_VL_STRING_FLOAT, key0);
17888 InsertVLVal(valsds0, VL_MAP_VL_STRING_FLOAT, key0, buf0);
17889 }
17890 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17891}
17892template<>
17893void Hdf5Back::WriteToBuf<MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17894 std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17895 size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[0]);
17896 size_t length0=shape[0];
17897 size_t item_size1key=CYCLUS_SHA1_SIZE;
17898 size_t item_size1val=sizeof(double);
17899 size_t total_item_size0=item_size1key+item_size1val;
17900 if(total_item_size0*val0.size()>column){
17901 std::map<std::string, double>::iterator eraseit=val0.begin();
17902 std::advance(eraseit, column/total_item_size0);
17903 val0.erase(eraseit,val0.end());
17904
17905 }
17906 unsigned int count0=0;
17907 std::map<std::string, double>::iterator it0=val0.begin();
17908 for(;it0!=val0.end();++it0){
17909 hasher_.Clear();
17910 hasher_.Update(it0->first);
17911 Digest key1key = hasher_.digest();
17912 hid_t keysds1key = VLDataset(VL_STRING, true);
17913 hid_t valsds1key = VLDataset(VL_STRING, false);
17914 if (vlkeys_[VL_STRING].count(key1key) != 1) {
17915 AppendVLKey(keysds1key, VL_STRING, key1key);
17916 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17917 }
17918 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
17919 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17920 ++count0;
17921
17922 }
17923 if(total_item_size0*length0<column){
17924 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17925
17926 }
17927}
17928template<>
17929void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17930 std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17931 size_t item_size0=(CYCLUS_SHA1_SIZE);
17932 size_t item_size1key=CYCLUS_SHA1_SIZE;
17933 size_t item_size1val=sizeof(double);
17934 size_t total_item_size0=item_size1key+item_size1val;
17935 hasher_.Clear();
17936 hasher_.Update(val0);
17937 Digest key0 = hasher_.digest();
17938 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
17939 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
17940 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
17941 hvl_t buf0 = VLValToBuf(val0);
17942 AppendVLKey(keysds0, VL_MAP_VL_STRING_DOUBLE, key0);
17943 InsertVLVal(valsds0, VL_MAP_VL_STRING_DOUBLE, key0, buf0);
17944 }
17945 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
17946}
17947template<>
17948void Hdf5Back::WriteToBuf<MAP_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17949 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17950 size_t item_size0=((CYCLUS_SHA1_SIZE+shape[2])*shape[0]);
17951 size_t length0=shape[0];
17952 size_t item_size1key=CYCLUS_SHA1_SIZE;
17953 size_t item_size1val=shape[2];
17954 size_t valuelen1val;
17955 size_t total_item_size0=item_size1key+item_size1val;
17956 if(total_item_size0*val0.size()>column){
17957 std::map<std::string, std::string>::iterator eraseit=val0.begin();
17958 std::advance(eraseit, column/total_item_size0);
17959 val0.erase(eraseit,val0.end());
17960
17961 }
17962 unsigned int count0=0;
17963 std::map<std::string, std::string>::iterator it0=val0.begin();
17964 for(;it0!=val0.end();++it0){
17965 hasher_.Clear();
17966 hasher_.Update(it0->first);
17967 Digest key1key = hasher_.digest();
17968 hid_t keysds1key = VLDataset(VL_STRING, true);
17969 hid_t valsds1key = VLDataset(VL_STRING, false);
17970 if (vlkeys_[VL_STRING].count(key1key) != 1) {
17971 AppendVLKey(keysds1key, VL_STRING, key1key);
17972 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17973 }
17974 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
17975 valuelen1val=std::min(it0->second.size(), item_size1val);
17976 memcpy(buf+(count0*total_item_size0)+0+item_size1key, it0->second.c_str(), valuelen1val);
17977 memset(buf+(count0*total_item_size0)+0+item_size1key+valuelen1val, 0, item_size1val-valuelen1val);
17978 ++count0;
17979
17980 }
17981 if(total_item_size0*length0<column){
17982 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17983
17984 }
17985}
17986template<>
17987void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17988 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17989 size_t item_size0=(CYCLUS_SHA1_SIZE);
17990 size_t item_size1key=CYCLUS_SHA1_SIZE;
17991 size_t item_size1val=shape[2];
17992 size_t valuelen1val;
17993 size_t total_item_size0=item_size1key+item_size1val;
17994 unsigned int count0=0;
17995 std::map<std::string, std::string>::iterator it0=val0.begin();
17996 std::map<std::string, std::string> fixed_val0;
17997 unsigned int pad_count0=0;
17998 for(;it0!=val0.end();++it0){
17999 std::string child1val=std::string(it0->second,0,item_size1val);
18000 fixed_val0[it0->first] = child1val;
18001 ++pad_count0;
18002
18003 }
18004 hasher_.Clear();
18005 hasher_.Update(fixed_val0);
18006 Digest key0 = hasher_.digest();
18007 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_STRING, true);
18008 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_STRING, false);
18009 if (vlkeys_[VL_MAP_VL_STRING_STRING].count(key0) != 1) {
18010 hvl_t buf0 = VLValToBuf(fixed_val0);
18011 AppendVLKey(keysds0, VL_MAP_VL_STRING_STRING, key0);
18012 InsertVLVal(valsds0, VL_MAP_VL_STRING_STRING, key0, buf0);
18013 }
18014 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18015}
18016template<>
18017void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18018 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
18019 size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
18020 size_t length0=shape[0];
18021 size_t item_size1key=CYCLUS_SHA1_SIZE;
18022 size_t item_size1val=CYCLUS_SHA1_SIZE;
18023 size_t total_item_size0=item_size1key+item_size1val;
18024 if(total_item_size0*val0.size()>column){
18025 std::map<std::string, std::string>::iterator eraseit=val0.begin();
18026 std::advance(eraseit, column/total_item_size0);
18027 val0.erase(eraseit,val0.end());
18028
18029 }
18030 unsigned int count0=0;
18031 std::map<std::string, std::string>::iterator it0=val0.begin();
18032 for(;it0!=val0.end();++it0){
18033 hasher_.Clear();
18034 hasher_.Update(it0->first);
18035 Digest key1key = hasher_.digest();
18036 hid_t keysds1key = VLDataset(VL_STRING, true);
18037 hid_t valsds1key = VLDataset(VL_STRING, false);
18038 if (vlkeys_[VL_STRING].count(key1key) != 1) {
18039 AppendVLKey(keysds1key, VL_STRING, key1key);
18040 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18041 }
18042 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
18043 hasher_.Clear();
18044 hasher_.Update(it0->second);
18045 Digest key1val = hasher_.digest();
18046 hid_t keysds1val = VLDataset(VL_STRING, true);
18047 hid_t valsds1val = VLDataset(VL_STRING, false);
18048 if (vlkeys_[VL_STRING].count(key1val) != 1) {
18049 AppendVLKey(keysds1val, VL_STRING, key1val);
18050 InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
18051 }
18052 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
18053 ++count0;
18054
18055 }
18056 if(total_item_size0*length0<column){
18057 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18058
18059 }
18060}
18061template<>
18062void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18063 std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
18064 size_t item_size0=(CYCLUS_SHA1_SIZE);
18065 size_t item_size1key=CYCLUS_SHA1_SIZE;
18066 size_t item_size1val=CYCLUS_SHA1_SIZE;
18067 size_t total_item_size0=item_size1key+item_size1val;
18068 hasher_.Clear();
18069 hasher_.Update(val0);
18070 Digest key0 = hasher_.digest();
18071 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_STRING, true);
18072 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_STRING, false);
18073 if (vlkeys_[VL_MAP_VL_STRING_VL_STRING].count(key0) != 1) {
18074 hvl_t buf0 = VLValToBuf(val0);
18075 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_STRING, key0);
18076 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_STRING, key0, buf0);
18077 }
18078 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18079}
18080template<>
18081void Hdf5Back::WriteToBuf<MAP_VL_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18082 std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
18083 size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
18084 size_t length0=shape[0];
18085 size_t item_size1key=CYCLUS_SHA1_SIZE;
18086 size_t item_size1val=CYCLUS_SHA1_SIZE;
18087 size_t total_item_size0=item_size1key+item_size1val;
18088 if(total_item_size0*val0.size()>column){
18089 std::map<std::string, cyclus::Blob>::iterator eraseit=val0.begin();
18090 std::advance(eraseit, column/total_item_size0);
18091 val0.erase(eraseit,val0.end());
18092
18093 }
18094 unsigned int count0=0;
18095 std::map<std::string, cyclus::Blob>::iterator it0=val0.begin();
18096 for(;it0!=val0.end();++it0){
18097 hasher_.Clear();
18098 hasher_.Update(it0->first);
18099 Digest key1key = hasher_.digest();
18100 hid_t keysds1key = VLDataset(VL_STRING, true);
18101 hid_t valsds1key = VLDataset(VL_STRING, false);
18102 if (vlkeys_[VL_STRING].count(key1key) != 1) {
18103 AppendVLKey(keysds1key, VL_STRING, key1key);
18104 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18105 }
18106 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
18107 hasher_.Clear();
18108 hasher_.Update(it0->second);
18109 Digest key1val = hasher_.digest();
18110 hid_t keysds1val = VLDataset(BLOB, true);
18111 hid_t valsds1val = VLDataset(BLOB, false);
18112 if (vlkeys_[BLOB].count(key1val) != 1) {
18113 AppendVLKey(keysds1val, BLOB, key1val);
18114 InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
18115 }
18116 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
18117 ++count0;
18118
18119 }
18120 if(total_item_size0*length0<column){
18121 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18122
18123 }
18124}
18125template<>
18126void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18127 std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
18128 size_t item_size0=(CYCLUS_SHA1_SIZE);
18129 size_t item_size1key=CYCLUS_SHA1_SIZE;
18130 size_t item_size1val=CYCLUS_SHA1_SIZE;
18131 size_t total_item_size0=item_size1key+item_size1val;
18132 hasher_.Clear();
18133 hasher_.Update(val0);
18134 Digest key0 = hasher_.digest();
18135 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_BLOB, true);
18136 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_BLOB, false);
18137 if (vlkeys_[VL_MAP_VL_STRING_BLOB].count(key0) != 1) {
18138 hvl_t buf0 = VLValToBuf(val0);
18139 AppendVLKey(keysds0, VL_MAP_VL_STRING_BLOB, key0);
18140 InsertVLVal(valsds0, VL_MAP_VL_STRING_BLOB, key0, buf0);
18141 }
18142 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18143}
18144template<>
18145void Hdf5Back::WriteToBuf<MAP_VL_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18146 std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
18147 size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE)*shape[0]);
18148 size_t length0=shape[0];
18149 size_t item_size1key=CYCLUS_SHA1_SIZE;
18150 size_t item_size1val=CYCLUS_UUID_SIZE;
18151 size_t total_item_size0=item_size1key+item_size1val;
18152 if(total_item_size0*val0.size()>column){
18153 std::map<std::string, boost::uuids::uuid>::iterator eraseit=val0.begin();
18154 std::advance(eraseit, column/total_item_size0);
18155 val0.erase(eraseit,val0.end());
18156
18157 }
18158 unsigned int count0=0;
18159 std::map<std::string, boost::uuids::uuid>::iterator it0=val0.begin();
18160 for(;it0!=val0.end();++it0){
18161 hasher_.Clear();
18162 hasher_.Update(it0->first);
18163 Digest key1key = hasher_.digest();
18164 hid_t keysds1key = VLDataset(VL_STRING, true);
18165 hid_t valsds1key = VLDataset(VL_STRING, false);
18166 if (vlkeys_[VL_STRING].count(key1key) != 1) {
18167 AppendVLKey(keysds1key, VL_STRING, key1key);
18168 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18169 }
18170 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
18171 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
18172 ++count0;
18173
18174 }
18175 if(total_item_size0*length0<column){
18176 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18177
18178 }
18179}
18180template<>
18181void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18182 std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
18183 size_t item_size0=(CYCLUS_SHA1_SIZE);
18184 size_t item_size1key=CYCLUS_SHA1_SIZE;
18185 size_t item_size1val=CYCLUS_UUID_SIZE;
18186 size_t total_item_size0=item_size1key+item_size1val;
18187 hasher_.Clear();
18188 hasher_.Update(val0);
18189 Digest key0 = hasher_.digest();
18190 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_UUID, true);
18191 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_UUID, false);
18192 if (vlkeys_[VL_MAP_VL_STRING_UUID].count(key0) != 1) {
18193 hvl_t buf0 = VLValToBuf(val0);
18194 AppendVLKey(keysds0, VL_MAP_VL_STRING_UUID, key0);
18195 InsertVLVal(valsds0, VL_MAP_VL_STRING_UUID, key0, buf0);
18196 }
18197 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18198}
18199template<>
18200void Hdf5Back::WriteToBuf<MAP_PAIR_INT_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18201 std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18202 size_t item_size0=((((sizeof(int)+shape[3]))+sizeof(double))*shape[0]);
18203 size_t length0=shape[0];
18204 size_t item_size1key=((sizeof(int)+shape[3]));
18205 size_t item_size2keyfirst=sizeof(int);
18206 size_t item_size2keysecond=shape[3];
18207 size_t valuelen2keysecond;
18208 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18209 size_t item_size1val=sizeof(double);
18210 size_t total_item_size0=item_size1key+item_size1val;
18211 if(total_item_size0*val0.size()>column){
18212 std::map<std::pair<int, std::string>, double>::iterator eraseit=val0.begin();
18213 std::advance(eraseit, column/total_item_size0);
18214 val0.erase(eraseit,val0.end());
18215
18216 }
18217 unsigned int count0=0;
18218 std::map<std::pair<int, std::string>, double>::iterator it0=val0.begin();
18219 for(;it0!=val0.end();++it0){
18220 unsigned int count1key=0;
18221 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, &(it0->first.first), item_size2keyfirst);
18222 valuelen2keysecond=std::min(it0->first.second.size(), item_size2keysecond);
18223 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, it0->first.second.c_str(), valuelen2keysecond);
18224 memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst+valuelen2keysecond, 0, item_size2keysecond-valuelen2keysecond);
18225 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
18226 ++count0;
18227
18228 }
18229 if(total_item_size0*length0<column){
18230 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18231
18232 }
18233}
18234template<>
18235void Hdf5Back::WriteToBuf<VL_MAP_PAIR_INT_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18236 std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18237 size_t item_size0=(CYCLUS_SHA1_SIZE);
18238 size_t item_size1key=((sizeof(int)+shape[3]));
18239 size_t item_size2keyfirst=sizeof(int);
18240 size_t item_size2keysecond=shape[3];
18241 size_t valuelen2keysecond;
18242 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18243 size_t item_size1val=sizeof(double);
18244 size_t total_item_size0=item_size1key+item_size1val;
18245 unsigned int count0=0;
18246 std::map<std::pair<int, std::string>, double>::iterator it0=val0.begin();
18247 std::map<std::pair<int, std::string>, double> fixed_val0;
18248 unsigned int pad_count0=0;
18249 for(;it0!=val0.end();++it0){
18250 std::pair<int, std::string> child1key;
18251 unsigned int pad_count1key=0;
18252 std::string child2keysecond=std::string(it0->first.second,0,item_size2keysecond);
18253 child1key = std::make_pair(it0->first.first,child2keysecond);
18254 fixed_val0[child1key] = it0->second;
18255 ++pad_count0;
18256
18257 }
18258 hasher_.Clear();
18259 hasher_.Update(fixed_val0);
18260 Digest key0 = hasher_.digest();
18261 hid_t keysds0 = VLDataset(VL_MAP_PAIR_INT_STRING_DOUBLE, true);
18262 hid_t valsds0 = VLDataset(VL_MAP_PAIR_INT_STRING_DOUBLE, false);
18263 if (vlkeys_[VL_MAP_PAIR_INT_STRING_DOUBLE].count(key0) != 1) {
18264 hvl_t buf0 = VLValToBuf(fixed_val0);
18265 AppendVLKey(keysds0, VL_MAP_PAIR_INT_STRING_DOUBLE, key0);
18266 InsertVLVal(valsds0, VL_MAP_PAIR_INT_STRING_DOUBLE, key0, buf0);
18267 }
18268 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18269}
18270template<>
18271void Hdf5Back::WriteToBuf<MAP_PAIR_INT_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18272 std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18273 size_t item_size0=((((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double))*shape[0]);
18274 size_t length0=shape[0];
18275 size_t item_size1key=((sizeof(int)+CYCLUS_SHA1_SIZE));
18276 size_t item_size2keyfirst=sizeof(int);
18277 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
18278 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18279 size_t item_size1val=sizeof(double);
18280 size_t total_item_size0=item_size1key+item_size1val;
18281 if(total_item_size0*val0.size()>column){
18282 std::map<std::pair<int, std::string>, double>::iterator eraseit=val0.begin();
18283 std::advance(eraseit, column/total_item_size0);
18284 val0.erase(eraseit,val0.end());
18285
18286 }
18287 unsigned int count0=0;
18288 std::map<std::pair<int, std::string>, double>::iterator it0=val0.begin();
18289 for(;it0!=val0.end();++it0){
18290 unsigned int count1key=0;
18291 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, &(it0->first.first), item_size2keyfirst);
18292 hasher_.Clear();
18293 hasher_.Update(it0->first.second);
18294 Digest key2keysecond = hasher_.digest();
18295 hid_t keysds2keysecond = VLDataset(VL_STRING, true);
18296 hid_t valsds2keysecond = VLDataset(VL_STRING, false);
18297 if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
18298 AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
18299 InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
18300 }
18301 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, key2keysecond.data(), CYCLUS_SHA1_SIZE);
18302 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
18303 ++count0;
18304
18305 }
18306 if(total_item_size0*length0<column){
18307 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18308
18309 }
18310}
18311template<>
18312void Hdf5Back::WriteToBuf<VL_MAP_PAIR_INT_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18313 std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18314 size_t item_size0=(CYCLUS_SHA1_SIZE);
18315 size_t item_size1key=((sizeof(int)+CYCLUS_SHA1_SIZE));
18316 size_t item_size2keyfirst=sizeof(int);
18317 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
18318 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18319 size_t item_size1val=sizeof(double);
18320 size_t total_item_size0=item_size1key+item_size1val;
18321 hasher_.Clear();
18322 hasher_.Update(val0);
18323 Digest key0 = hasher_.digest();
18324 hid_t keysds0 = VLDataset(VL_MAP_PAIR_INT_VL_STRING_DOUBLE, true);
18325 hid_t valsds0 = VLDataset(VL_MAP_PAIR_INT_VL_STRING_DOUBLE, false);
18326 if (vlkeys_[VL_MAP_PAIR_INT_VL_STRING_DOUBLE].count(key0) != 1) {
18327 hvl_t buf0 = VLValToBuf(val0);
18328 AppendVLKey(keysds0, VL_MAP_PAIR_INT_VL_STRING_DOUBLE, key0);
18329 InsertVLVal(valsds0, VL_MAP_PAIR_INT_VL_STRING_DOUBLE, key0, buf0);
18330 }
18331 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18332}
18333template<>
18334void Hdf5Back::WriteToBuf<MAP_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18335 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18336 size_t item_size0=((shape[1]+((sizeof(double))*shape[2]))*shape[0]);
18337 size_t length0=shape[0];
18338 size_t item_size1key=shape[1];
18339 size_t valuelen1key;
18340 size_t item_size1val=((sizeof(double))*shape[2]);
18341 size_t length1val=shape[2];
18342 size_t item_size2valelem=sizeof(double);
18343 size_t total_item_size1val=item_size2valelem;
18344 size_t total_item_size0=item_size1key+item_size1val;
18345 if(total_item_size0*val0.size()>column){
18346 std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18347 std::advance(eraseit, column/total_item_size0);
18348 val0.erase(eraseit,val0.end());
18349
18350 }
18351 unsigned int count0=0;
18352 std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18353 for(;it0!=val0.end();++it0){
18354 valuelen1key=std::min(it0->first.size(), item_size1key);
18355 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18356 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18357 unsigned int count1val=0;
18358 std::vector<double>::iterator it1val=it0->second.begin();
18359 for(;it1val!=it0->second.end();++it1val){
18360 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val, &(*it1val), item_size2valelem);
18361 ++count1val;
18362
18363 }
18364 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18365 ++count0;
18366
18367 }
18368 if(total_item_size0*length0<column){
18369 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18370
18371 }
18372}
18373template<>
18374void Hdf5Back::WriteToBuf<MAP_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18375 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18376 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
18377 size_t length0=shape[0];
18378 size_t item_size1key=shape[1];
18379 size_t valuelen1key;
18380 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18381 size_t item_size2valelem=sizeof(double);
18382 size_t total_item_size1val=item_size2valelem;
18383 size_t total_item_size0=item_size1key+item_size1val;
18384 if(total_item_size0*val0.size()>column){
18385 std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18386 std::advance(eraseit, column/total_item_size0);
18387 val0.erase(eraseit,val0.end());
18388
18389 }
18390 unsigned int count0=0;
18391 std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18392 for(;it0!=val0.end();++it0){
18393 valuelen1key=std::min(it0->first.size(), item_size1key);
18394 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18395 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18396 hasher_.Clear();
18397 hasher_.Update(it0->second);
18398 Digest key1val = hasher_.digest();
18399 hid_t keysds1val = VLDataset(VL_VECTOR_DOUBLE, true);
18400 hid_t valsds1val = VLDataset(VL_VECTOR_DOUBLE, false);
18401 if (vlkeys_[VL_VECTOR_DOUBLE].count(key1val) != 1) {
18402 hvl_t buf1val = VLValToBuf(it0->second);
18403 AppendVLKey(keysds1val, VL_VECTOR_DOUBLE, key1val);
18404 InsertVLVal(valsds1val, VL_VECTOR_DOUBLE, key1val, buf1val);
18405 }
18406 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
18407 ++count0;
18408
18409 }
18410 if(total_item_size0*length0<column){
18411 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18412
18413 }
18414}
18415template<>
18416void Hdf5Back::WriteToBuf<VL_MAP_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18417 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18418 size_t item_size0=(CYCLUS_SHA1_SIZE);
18419 size_t item_size1key=shape[1];
18420 size_t valuelen1key;
18421 size_t item_size1val=((sizeof(double))*shape[2]);
18422 size_t length1val=shape[2];
18423 size_t item_size2valelem=sizeof(double);
18424 size_t total_item_size1val=item_size2valelem;
18425 size_t total_item_size0=item_size1key+item_size1val;
18426 unsigned int count0=0;
18427 std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18428 std::map<std::string, std::vector<double>> fixed_val0;
18429 unsigned int pad_count0=0;
18430 for(;it0!=val0.end();++it0){
18431 std::string child1key=std::string(it0->first,0,item_size1key);
18432 std::vector<double> child1val;
18433 unsigned int pad_count1val=0;
18434 std::vector<double>::iterator it1val=it0->second.begin();
18435 for(;it1val!=it0->second.end();++it1val){
18436 child1val.push_back((*it1val));
18437 ++pad_count1val;
18438
18439 }
18440 child1val.resize(length1val);
18441 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
18442 fixed_val0[child1key] = child1val;
18443 ++pad_count0;
18444
18445 }
18446 hasher_.Clear();
18447 hasher_.Update(fixed_val0);
18448 Digest key0 = hasher_.digest();
18449 hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_DOUBLE, true);
18450 hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_DOUBLE, false);
18451 if (vlkeys_[VL_MAP_STRING_VECTOR_DOUBLE].count(key0) != 1) {
18452 hvl_t buf0 = VLValToBuf(fixed_val0);
18453 AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_DOUBLE, key0);
18454 InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_DOUBLE, key0, buf0);
18455 }
18456 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18457}
18458template<>
18459void Hdf5Back::WriteToBuf<MAP_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18460 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18461 size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]))*shape[0]);
18462 size_t length0=shape[0];
18463 size_t item_size1key=CYCLUS_SHA1_SIZE;
18464 size_t item_size1val=((sizeof(double))*shape[2]);
18465 size_t length1val=shape[2];
18466 size_t item_size2valelem=sizeof(double);
18467 size_t total_item_size1val=item_size2valelem;
18468 size_t total_item_size0=item_size1key+item_size1val;
18469 if(total_item_size0*val0.size()>column){
18470 std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18471 std::advance(eraseit, column/total_item_size0);
18472 val0.erase(eraseit,val0.end());
18473
18474 }
18475 unsigned int count0=0;
18476 std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18477 for(;it0!=val0.end();++it0){
18478 hasher_.Clear();
18479 hasher_.Update(it0->first);
18480 Digest key1key = hasher_.digest();
18481 hid_t keysds1key = VLDataset(VL_STRING, true);
18482 hid_t valsds1key = VLDataset(VL_STRING, false);
18483 if (vlkeys_[VL_STRING].count(key1key) != 1) {
18484 AppendVLKey(keysds1key, VL_STRING, key1key);
18485 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18486 }
18487 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
18488 unsigned int count1val=0;
18489 std::vector<double>::iterator it1val=it0->second.begin();
18490 for(;it1val!=it0->second.end();++it1val){
18491 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val, &(*it1val), item_size2valelem);
18492 ++count1val;
18493
18494 }
18495 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18496 ++count0;
18497
18498 }
18499 if(total_item_size0*length0<column){
18500 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18501
18502 }
18503}
18504template<>
18505void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18506 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18507 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
18508 size_t length0=shape[0];
18509 size_t item_size1key=CYCLUS_SHA1_SIZE;
18510 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18511 size_t item_size2valelem=sizeof(double);
18512 size_t total_item_size1val=item_size2valelem;
18513 size_t total_item_size0=item_size1key+item_size1val;
18514 if(total_item_size0*val0.size()>column){
18515 std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18516 std::advance(eraseit, column/total_item_size0);
18517 val0.erase(eraseit,val0.end());
18518
18519 }
18520 unsigned int count0=0;
18521 std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18522 for(;it0!=val0.end();++it0){
18523 hasher_.Clear();
18524 hasher_.Update(it0->first);
18525 Digest key1key = hasher_.digest();
18526 hid_t keysds1key = VLDataset(VL_STRING, true);
18527 hid_t valsds1key = VLDataset(VL_STRING, false);
18528 if (vlkeys_[VL_STRING].count(key1key) != 1) {
18529 AppendVLKey(keysds1key, VL_STRING, key1key);
18530 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18531 }
18532 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
18533 hasher_.Clear();
18534 hasher_.Update(it0->second);
18535 Digest key1val = hasher_.digest();
18536 hid_t keysds1val = VLDataset(VL_VECTOR_DOUBLE, true);
18537 hid_t valsds1val = VLDataset(VL_VECTOR_DOUBLE, false);
18538 if (vlkeys_[VL_VECTOR_DOUBLE].count(key1val) != 1) {
18539 hvl_t buf1val = VLValToBuf(it0->second);
18540 AppendVLKey(keysds1val, VL_VECTOR_DOUBLE, key1val);
18541 InsertVLVal(valsds1val, VL_VECTOR_DOUBLE, key1val, buf1val);
18542 }
18543 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
18544 ++count0;
18545
18546 }
18547 if(total_item_size0*length0<column){
18548 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18549
18550 }
18551}
18552template<>
18553void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18554 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18555 size_t item_size0=(CYCLUS_SHA1_SIZE);
18556 size_t item_size1key=shape[1];
18557 size_t valuelen1key;
18558 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18559 size_t item_size2valelem=sizeof(double);
18560 size_t total_item_size1val=item_size2valelem;
18561 size_t total_item_size0=item_size1key+item_size1val;
18562 unsigned int count0=0;
18563 std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18564 std::map<std::string, std::vector<double>> fixed_val0;
18565 unsigned int pad_count0=0;
18566 for(;it0!=val0.end();++it0){
18567 std::string child1key=std::string(it0->first,0,item_size1key);
18568 fixed_val0[child1key] = it0->second;
18569 ++pad_count0;
18570
18571 }
18572 hasher_.Clear();
18573 hasher_.Update(fixed_val0);
18574 Digest key0 = hasher_.digest();
18575 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_DOUBLE, true);
18576 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_DOUBLE, false);
18577 if (vlkeys_[VL_MAP_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
18578 hvl_t buf0 = VLValToBuf(fixed_val0);
18579 AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_DOUBLE, key0);
18580 InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_DOUBLE, key0, buf0);
18581 }
18582 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18583}
18584template<>
18585void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18586 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18587 size_t item_size0=(CYCLUS_SHA1_SIZE);
18588 size_t item_size1key=CYCLUS_SHA1_SIZE;
18589 size_t item_size1val=((sizeof(double))*shape[2]);
18590 size_t length1val=shape[2];
18591 size_t item_size2valelem=sizeof(double);
18592 size_t total_item_size1val=item_size2valelem;
18593 size_t total_item_size0=item_size1key+item_size1val;
18594 unsigned int count0=0;
18595 std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18596 std::map<std::string, std::vector<double>> fixed_val0;
18597 unsigned int pad_count0=0;
18598 for(;it0!=val0.end();++it0){
18599 std::vector<double> child1val;
18600 unsigned int pad_count1val=0;
18601 std::vector<double>::iterator it1val=it0->second.begin();
18602 for(;it1val!=it0->second.end();++it1val){
18603 child1val.push_back((*it1val));
18604 ++pad_count1val;
18605
18606 }
18607 child1val.resize(length1val);
18608 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
18609 fixed_val0[it0->first] = child1val;
18610 ++pad_count0;
18611
18612 }
18613 hasher_.Clear();
18614 hasher_.Update(fixed_val0);
18615 Digest key0 = hasher_.digest();
18616 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_DOUBLE, true);
18617 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_DOUBLE, false);
18618 if (vlkeys_[VL_MAP_VL_STRING_VECTOR_DOUBLE].count(key0) != 1) {
18619 hvl_t buf0 = VLValToBuf(fixed_val0);
18620 AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_DOUBLE, key0);
18621 InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_DOUBLE, key0, buf0);
18622 }
18623 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18624}
18625template<>
18626void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18627 std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18628 size_t item_size0=(CYCLUS_SHA1_SIZE);
18629 size_t item_size1key=CYCLUS_SHA1_SIZE;
18630 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18631 size_t item_size2valelem=sizeof(double);
18632 size_t total_item_size1val=item_size2valelem;
18633 size_t total_item_size0=item_size1key+item_size1val;
18634 hasher_.Clear();
18635 hasher_.Update(val0);
18636 Digest key0 = hasher_.digest();
18637 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, true);
18638 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, false);
18639 if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
18640 hvl_t buf0 = VLValToBuf(val0);
18641 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, key0);
18642 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, key0, buf0);
18643 }
18644 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18645}
18646template<>
18647void Hdf5Back::WriteToBuf<MAP_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18648 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18649 size_t item_size0=((shape[1]+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
18650 size_t length0=shape[0];
18651 size_t item_size1key=shape[1];
18652 size_t valuelen1key;
18653 size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18654 size_t length1val=shape[2];
18655 size_t item_size2valkey=sizeof(int);
18656 size_t item_size2valval=sizeof(double);
18657 size_t total_item_size1val=item_size2valkey+item_size2valval;
18658 size_t total_item_size0=item_size1key+item_size1val;
18659 if(total_item_size0*val0.size()>column){
18660 std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18661 std::advance(eraseit, column/total_item_size0);
18662 val0.erase(eraseit,val0.end());
18663
18664 }
18665 unsigned int count0=0;
18666 std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18667 for(;it0!=val0.end();++it0){
18668 valuelen1key=std::min(it0->first.size(), item_size1key);
18669 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18670 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18671 unsigned int count1val=0;
18672 std::map<int, double>::iterator it1val=it0->second.begin();
18673 for(;it1val!=it0->second.end();++it1val){
18674 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it1val->first), item_size2valkey);
18675 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
18676 ++count1val;
18677
18678 }
18679 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18680 ++count0;
18681
18682 }
18683 if(total_item_size0*length0<column){
18684 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18685
18686 }
18687}
18688template<>
18689void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18690 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18691 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
18692 size_t length0=shape[0];
18693 size_t item_size1key=shape[1];
18694 size_t valuelen1key;
18695 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18696 size_t item_size2valkey=sizeof(int);
18697 size_t item_size2valval=sizeof(double);
18698 size_t total_item_size1val=item_size2valkey+item_size2valval;
18699 size_t total_item_size0=item_size1key+item_size1val;
18700 if(total_item_size0*val0.size()>column){
18701 std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18702 std::advance(eraseit, column/total_item_size0);
18703 val0.erase(eraseit,val0.end());
18704
18705 }
18706 unsigned int count0=0;
18707 std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18708 for(;it0!=val0.end();++it0){
18709 valuelen1key=std::min(it0->first.size(), item_size1key);
18710 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18711 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18712 hasher_.Clear();
18713 hasher_.Update(it0->second);
18714 Digest key1val = hasher_.digest();
18715 hid_t keysds1val = VLDataset(VL_MAP_INT_DOUBLE, true);
18716 hid_t valsds1val = VLDataset(VL_MAP_INT_DOUBLE, false);
18717 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1val) != 1) {
18718 hvl_t buf1val = VLValToBuf(it0->second);
18719 AppendVLKey(keysds1val, VL_MAP_INT_DOUBLE, key1val);
18720 InsertVLVal(valsds1val, VL_MAP_INT_DOUBLE, key1val, buf1val);
18721 }
18722 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
18723 ++count0;
18724
18725 }
18726 if(total_item_size0*length0<column){
18727 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18728
18729 }
18730}
18731template<>
18732void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18733 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18734 size_t item_size0=(CYCLUS_SHA1_SIZE);
18735 size_t item_size1key=shape[1];
18736 size_t valuelen1key;
18737 size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18738 size_t length1val=shape[2];
18739 size_t item_size2valkey=sizeof(int);
18740 size_t item_size2valval=sizeof(double);
18741 size_t total_item_size1val=item_size2valkey+item_size2valval;
18742 size_t total_item_size0=item_size1key+item_size1val;
18743 unsigned int count0=0;
18744 std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18745 std::map<std::string, std::map<int, double>> fixed_val0;
18746 unsigned int pad_count0=0;
18747 for(;it0!=val0.end();++it0){
18748 std::string child1key=std::string(it0->first,0,item_size1key);
18749 std::map<int, double> child1val;
18750 unsigned int pad_count1val=0;
18751 std::map<int, double>::iterator it1val=it0->second.begin();
18752 for(;it1val!=it0->second.end();++it1val){
18753 child1val[it1val->first] = it1val->second;
18754 ++pad_count1val;
18755
18756 }
18757 fixed_val0[child1key] = child1val;
18758 ++pad_count0;
18759
18760 }
18761 hasher_.Clear();
18762 hasher_.Update(fixed_val0);
18763 Digest key0 = hasher_.digest();
18764 hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_INT_DOUBLE, true);
18765 hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_INT_DOUBLE, false);
18766 if (vlkeys_[VL_MAP_STRING_MAP_INT_DOUBLE].count(key0) != 1) {
18767 hvl_t buf0 = VLValToBuf(fixed_val0);
18768 AppendVLKey(keysds0, VL_MAP_STRING_MAP_INT_DOUBLE, key0);
18769 InsertVLVal(valsds0, VL_MAP_STRING_MAP_INT_DOUBLE, key0, buf0);
18770 }
18771 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18772}
18773template<>
18774void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18775 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18776 size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
18777 size_t length0=shape[0];
18778 size_t item_size1key=CYCLUS_SHA1_SIZE;
18779 size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18780 size_t length1val=shape[2];
18781 size_t item_size2valkey=sizeof(int);
18782 size_t item_size2valval=sizeof(double);
18783 size_t total_item_size1val=item_size2valkey+item_size2valval;
18784 size_t total_item_size0=item_size1key+item_size1val;
18785 if(total_item_size0*val0.size()>column){
18786 std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18787 std::advance(eraseit, column/total_item_size0);
18788 val0.erase(eraseit,val0.end());
18789
18790 }
18791 unsigned int count0=0;
18792 std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18793 for(;it0!=val0.end();++it0){
18794 hasher_.Clear();
18795 hasher_.Update(it0->first);
18796 Digest key1key = hasher_.digest();
18797 hid_t keysds1key = VLDataset(VL_STRING, true);
18798 hid_t valsds1key = VLDataset(VL_STRING, false);
18799 if (vlkeys_[VL_STRING].count(key1key) != 1) {
18800 AppendVLKey(keysds1key, VL_STRING, key1key);
18801 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18802 }
18803 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
18804 unsigned int count1val=0;
18805 std::map<int, double>::iterator it1val=it0->second.begin();
18806 for(;it1val!=it0->second.end();++it1val){
18807 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it1val->first), item_size2valkey);
18808 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
18809 ++count1val;
18810
18811 }
18812 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18813 ++count0;
18814
18815 }
18816 if(total_item_size0*length0<column){
18817 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18818
18819 }
18820}
18821template<>
18822void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18823 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18824 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
18825 size_t length0=shape[0];
18826 size_t item_size1key=CYCLUS_SHA1_SIZE;
18827 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18828 size_t item_size2valkey=sizeof(int);
18829 size_t item_size2valval=sizeof(double);
18830 size_t total_item_size1val=item_size2valkey+item_size2valval;
18831 size_t total_item_size0=item_size1key+item_size1val;
18832 if(total_item_size0*val0.size()>column){
18833 std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18834 std::advance(eraseit, column/total_item_size0);
18835 val0.erase(eraseit,val0.end());
18836
18837 }
18838 unsigned int count0=0;
18839 std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18840 for(;it0!=val0.end();++it0){
18841 hasher_.Clear();
18842 hasher_.Update(it0->first);
18843 Digest key1key = hasher_.digest();
18844 hid_t keysds1key = VLDataset(VL_STRING, true);
18845 hid_t valsds1key = VLDataset(VL_STRING, false);
18846 if (vlkeys_[VL_STRING].count(key1key) != 1) {
18847 AppendVLKey(keysds1key, VL_STRING, key1key);
18848 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18849 }
18850 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
18851 hasher_.Clear();
18852 hasher_.Update(it0->second);
18853 Digest key1val = hasher_.digest();
18854 hid_t keysds1val = VLDataset(VL_MAP_INT_DOUBLE, true);
18855 hid_t valsds1val = VLDataset(VL_MAP_INT_DOUBLE, false);
18856 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1val) != 1) {
18857 hvl_t buf1val = VLValToBuf(it0->second);
18858 AppendVLKey(keysds1val, VL_MAP_INT_DOUBLE, key1val);
18859 InsertVLVal(valsds1val, VL_MAP_INT_DOUBLE, key1val, buf1val);
18860 }
18861 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
18862 ++count0;
18863
18864 }
18865 if(total_item_size0*length0<column){
18866 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18867
18868 }
18869}
18870template<>
18871void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18872 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18873 size_t item_size0=(CYCLUS_SHA1_SIZE);
18874 size_t item_size1key=shape[1];
18875 size_t valuelen1key;
18876 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18877 size_t item_size2valkey=sizeof(int);
18878 size_t item_size2valval=sizeof(double);
18879 size_t total_item_size1val=item_size2valkey+item_size2valval;
18880 size_t total_item_size0=item_size1key+item_size1val;
18881 unsigned int count0=0;
18882 std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18883 std::map<std::string, std::map<int, double>> fixed_val0;
18884 unsigned int pad_count0=0;
18885 for(;it0!=val0.end();++it0){
18886 std::string child1key=std::string(it0->first,0,item_size1key);
18887 fixed_val0[child1key] = it0->second;
18888 ++pad_count0;
18889
18890 }
18891 hasher_.Clear();
18892 hasher_.Update(fixed_val0);
18893 Digest key0 = hasher_.digest();
18894 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_INT_DOUBLE, true);
18895 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_INT_DOUBLE, false);
18896 if (vlkeys_[VL_MAP_STRING_VL_MAP_INT_DOUBLE].count(key0) != 1) {
18897 hvl_t buf0 = VLValToBuf(fixed_val0);
18898 AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_INT_DOUBLE, key0);
18899 InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_INT_DOUBLE, key0, buf0);
18900 }
18901 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18902}
18903template<>
18904void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18905 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18906 size_t item_size0=(CYCLUS_SHA1_SIZE);
18907 size_t item_size1key=CYCLUS_SHA1_SIZE;
18908 size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18909 size_t length1val=shape[2];
18910 size_t item_size2valkey=sizeof(int);
18911 size_t item_size2valval=sizeof(double);
18912 size_t total_item_size1val=item_size2valkey+item_size2valval;
18913 size_t total_item_size0=item_size1key+item_size1val;
18914 unsigned int count0=0;
18915 std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18916 std::map<std::string, std::map<int, double>> fixed_val0;
18917 unsigned int pad_count0=0;
18918 for(;it0!=val0.end();++it0){
18919 std::map<int, double> child1val;
18920 unsigned int pad_count1val=0;
18921 std::map<int, double>::iterator it1val=it0->second.begin();
18922 for(;it1val!=it0->second.end();++it1val){
18923 child1val[it1val->first] = it1val->second;
18924 ++pad_count1val;
18925
18926 }
18927 fixed_val0[it0->first] = child1val;
18928 ++pad_count0;
18929
18930 }
18931 hasher_.Clear();
18932 hasher_.Update(fixed_val0);
18933 Digest key0 = hasher_.digest();
18934 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_INT_DOUBLE, true);
18935 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_INT_DOUBLE, false);
18936 if (vlkeys_[VL_MAP_VL_STRING_MAP_INT_DOUBLE].count(key0) != 1) {
18937 hvl_t buf0 = VLValToBuf(fixed_val0);
18938 AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_INT_DOUBLE, key0);
18939 InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_INT_DOUBLE, key0, buf0);
18940 }
18941 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18942}
18943template<>
18944void 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) {
18945 std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18946 size_t item_size0=(CYCLUS_SHA1_SIZE);
18947 size_t item_size1key=CYCLUS_SHA1_SIZE;
18948 size_t item_size1val=(CYCLUS_SHA1_SIZE);
18949 size_t item_size2valkey=sizeof(int);
18950 size_t item_size2valval=sizeof(double);
18951 size_t total_item_size1val=item_size2valkey+item_size2valval;
18952 size_t total_item_size0=item_size1key+item_size1val;
18953 hasher_.Clear();
18954 hasher_.Update(val0);
18955 Digest key0 = hasher_.digest();
18956 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, true);
18957 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, false);
18958 if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE].count(key0) != 1) {
18959 hvl_t buf0 = VLValToBuf(val0);
18960 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, key0);
18961 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, key0, buf0);
18962 }
18963 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
18964}
18965template<>
18966void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18967 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>>>>();
18968 size_t item_size0=((shape[1]+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
18969 size_t length0=shape[0];
18970 size_t item_size1key=shape[1];
18971 size_t valuelen1key;
18972 size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
18973 size_t item_size2valfirst=sizeof(double);
18974 size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
18975 size_t length2valsecond=shape[4];
18976 size_t item_size3valsecondkey=sizeof(int);
18977 size_t item_size3valsecondval=sizeof(double);
18978 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
18979 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
18980 size_t total_item_size0=item_size1key+item_size1val;
18981 if(total_item_size0*val0.size()>column){
18982 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
18983 std::advance(eraseit, column/total_item_size0);
18984 val0.erase(eraseit,val0.end());
18985
18986 }
18987 unsigned int count0=0;
18988 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
18989 for(;it0!=val0.end();++it0){
18990 valuelen1key=std::min(it0->first.size(), item_size1key);
18991 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18992 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18993 unsigned int count1val=0;
18994 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
18995 unsigned int count2valsecond=0;
18996 std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
18997 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
18998 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);
18999 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);
19000 ++count2valsecond;
19001
19002 }
19003 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));
19004 ++count0;
19005
19006 }
19007 if(total_item_size0*length0<column){
19008 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19009
19010 }
19011}
19012template<>
19013void 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) {
19014 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>>>>();
19015 size_t item_size0=(CYCLUS_SHA1_SIZE);
19016 size_t item_size1key=shape[1];
19017 size_t valuelen1key;
19018 size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
19019 size_t item_size2valfirst=sizeof(double);
19020 size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
19021 size_t length2valsecond=shape[4];
19022 size_t item_size3valsecondkey=sizeof(int);
19023 size_t item_size3valsecondval=sizeof(double);
19024 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19025 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19026 size_t total_item_size0=item_size1key+item_size1val;
19027 unsigned int count0=0;
19028 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19029 std::map<std::string, std::pair<double, std::map<int, double>>> fixed_val0;
19030 unsigned int pad_count0=0;
19031 for(;it0!=val0.end();++it0){
19032 std::string child1key=std::string(it0->first,0,item_size1key);
19033 std::pair<double, std::map<int, double>> child1val;
19034 unsigned int pad_count1val=0;
19035 std::map<int, double> child2valsecond;
19036 unsigned int pad_count2valsecond=0;
19037 std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
19038 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
19039 child2valsecond[it2valsecond->first] = it2valsecond->second;
19040 ++pad_count2valsecond;
19041
19042 }
19043 child1val = std::make_pair(it0->second.first,child2valsecond);
19044 fixed_val0[child1key] = child1val;
19045 ++pad_count0;
19046
19047 }
19048 hasher_.Clear();
19049 hasher_.Update(fixed_val0);
19050 Digest key0 = hasher_.digest();
19051 hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, true);
19052 hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, false);
19053 if (vlkeys_[VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE].count(key0) != 1) {
19054 hvl_t buf0 = VLValToBuf(fixed_val0);
19055 AppendVLKey(keysds0, VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0);
19056 InsertVLVal(valsds0, VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0, buf0);
19057 }
19058 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19059}
19060template<>
19061void 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) {
19062 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>>>>();
19063 size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
19064 size_t length0=shape[0];
19065 size_t item_size1key=CYCLUS_SHA1_SIZE;
19066 size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
19067 size_t item_size2valfirst=sizeof(double);
19068 size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
19069 size_t length2valsecond=shape[4];
19070 size_t item_size3valsecondkey=sizeof(int);
19071 size_t item_size3valsecondval=sizeof(double);
19072 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19073 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19074 size_t total_item_size0=item_size1key+item_size1val;
19075 if(total_item_size0*val0.size()>column){
19076 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
19077 std::advance(eraseit, column/total_item_size0);
19078 val0.erase(eraseit,val0.end());
19079
19080 }
19081 unsigned int count0=0;
19082 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19083 for(;it0!=val0.end();++it0){
19084 hasher_.Clear();
19085 hasher_.Update(it0->first);
19086 Digest key1key = hasher_.digest();
19087 hid_t keysds1key = VLDataset(VL_STRING, true);
19088 hid_t valsds1key = VLDataset(VL_STRING, false);
19089 if (vlkeys_[VL_STRING].count(key1key) != 1) {
19090 AppendVLKey(keysds1key, VL_STRING, key1key);
19091 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
19092 }
19093 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
19094 unsigned int count1val=0;
19095 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
19096 unsigned int count2valsecond=0;
19097 std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
19098 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
19099 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);
19100 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);
19101 ++count2valsecond;
19102
19103 }
19104 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));
19105 ++count0;
19106
19107 }
19108 if(total_item_size0*length0<column){
19109 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19110
19111 }
19112}
19113template<>
19114void 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) {
19115 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>>>>();
19116 size_t item_size0=((shape[1]+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
19117 size_t length0=shape[0];
19118 size_t item_size1key=shape[1];
19119 size_t valuelen1key;
19120 size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19121 size_t item_size2valfirst=sizeof(double);
19122 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19123 size_t item_size3valsecondkey=sizeof(int);
19124 size_t item_size3valsecondval=sizeof(double);
19125 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19126 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19127 size_t total_item_size0=item_size1key+item_size1val;
19128 if(total_item_size0*val0.size()>column){
19129 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
19130 std::advance(eraseit, column/total_item_size0);
19131 val0.erase(eraseit,val0.end());
19132
19133 }
19134 unsigned int count0=0;
19135 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19136 for(;it0!=val0.end();++it0){
19137 valuelen1key=std::min(it0->first.size(), item_size1key);
19138 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19139 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19140 unsigned int count1val=0;
19141 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
19142 hasher_.Clear();
19143 hasher_.Update(it0->second.second);
19144 Digest key2valsecond = hasher_.digest();
19145 hid_t keysds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, true);
19146 hid_t valsds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, false);
19147 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key2valsecond) != 1) {
19148 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
19149 AppendVLKey(keysds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond);
19150 InsertVLVal(valsds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond, buf2valsecond);
19151 }
19152 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.data(), CYCLUS_SHA1_SIZE);
19153 ++count0;
19154
19155 }
19156 if(total_item_size0*length0<column){
19157 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19158
19159 }
19160}
19161template<>
19162void 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) {
19163 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>>>>();
19164 size_t item_size0=(CYCLUS_SHA1_SIZE);
19165 size_t item_size1key=CYCLUS_SHA1_SIZE;
19166 size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
19167 size_t item_size2valfirst=sizeof(double);
19168 size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
19169 size_t length2valsecond=shape[4];
19170 size_t item_size3valsecondkey=sizeof(int);
19171 size_t item_size3valsecondval=sizeof(double);
19172 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19173 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19174 size_t total_item_size0=item_size1key+item_size1val;
19175 unsigned int count0=0;
19176 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19177 std::map<std::string, std::pair<double, std::map<int, double>>> fixed_val0;
19178 unsigned int pad_count0=0;
19179 for(;it0!=val0.end();++it0){
19180 std::pair<double, std::map<int, double>> child1val;
19181 unsigned int pad_count1val=0;
19182 std::map<int, double> child2valsecond;
19183 unsigned int pad_count2valsecond=0;
19184 std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
19185 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
19186 child2valsecond[it2valsecond->first] = it2valsecond->second;
19187 ++pad_count2valsecond;
19188
19189 }
19190 child1val = std::make_pair(it0->second.first,child2valsecond);
19191 fixed_val0[it0->first] = child1val;
19192 ++pad_count0;
19193
19194 }
19195 hasher_.Clear();
19196 hasher_.Update(fixed_val0);
19197 Digest key0 = hasher_.digest();
19198 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, true);
19199 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, false);
19200 if (vlkeys_[VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE].count(key0) != 1) {
19201 hvl_t buf0 = VLValToBuf(fixed_val0);
19202 AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0);
19203 InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0, buf0);
19204 }
19205 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19206}
19207template<>
19208void 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) {
19209 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>>>>();
19210 size_t item_size0=(CYCLUS_SHA1_SIZE);
19211 size_t item_size1key=shape[1];
19212 size_t valuelen1key;
19213 size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19214 size_t item_size2valfirst=sizeof(double);
19215 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19216 size_t item_size3valsecondkey=sizeof(int);
19217 size_t item_size3valsecondval=sizeof(double);
19218 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19219 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19220 size_t total_item_size0=item_size1key+item_size1val;
19221 unsigned int count0=0;
19222 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19223 std::map<std::string, std::pair<double, std::map<int, double>>> fixed_val0;
19224 unsigned int pad_count0=0;
19225 for(;it0!=val0.end();++it0){
19226 std::string child1key=std::string(it0->first,0,item_size1key);
19227 std::pair<double, std::map<int, double>> child1val;
19228 unsigned int pad_count1val=0;
19229 child1val = std::make_pair(it0->second.first,it0->second.second);
19230 fixed_val0[child1key] = child1val;
19231 ++pad_count0;
19232
19233 }
19234 hasher_.Clear();
19235 hasher_.Update(fixed_val0);
19236 Digest key0 = hasher_.digest();
19237 hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, true);
19238 hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, false);
19239 if (vlkeys_[VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE].count(key0) != 1) {
19240 hvl_t buf0 = VLValToBuf(fixed_val0);
19241 AppendVLKey(keysds0, VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0);
19242 InsertVLVal(valsds0, VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0, buf0);
19243 }
19244 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19245}
19246template<>
19247void 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) {
19248 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>>>>();
19249 size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
19250 size_t length0=shape[0];
19251 size_t item_size1key=CYCLUS_SHA1_SIZE;
19252 size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19253 size_t item_size2valfirst=sizeof(double);
19254 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19255 size_t item_size3valsecondkey=sizeof(int);
19256 size_t item_size3valsecondval=sizeof(double);
19257 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19258 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19259 size_t total_item_size0=item_size1key+item_size1val;
19260 if(total_item_size0*val0.size()>column){
19261 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
19262 std::advance(eraseit, column/total_item_size0);
19263 val0.erase(eraseit,val0.end());
19264
19265 }
19266 unsigned int count0=0;
19267 std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19268 for(;it0!=val0.end();++it0){
19269 hasher_.Clear();
19270 hasher_.Update(it0->first);
19271 Digest key1key = hasher_.digest();
19272 hid_t keysds1key = VLDataset(VL_STRING, true);
19273 hid_t valsds1key = VLDataset(VL_STRING, false);
19274 if (vlkeys_[VL_STRING].count(key1key) != 1) {
19275 AppendVLKey(keysds1key, VL_STRING, key1key);
19276 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
19277 }
19278 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
19279 unsigned int count1val=0;
19280 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
19281 hasher_.Clear();
19282 hasher_.Update(it0->second.second);
19283 Digest key2valsecond = hasher_.digest();
19284 hid_t keysds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, true);
19285 hid_t valsds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, false);
19286 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key2valsecond) != 1) {
19287 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
19288 AppendVLKey(keysds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond);
19289 InsertVLVal(valsds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond, buf2valsecond);
19290 }
19291 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.data(), CYCLUS_SHA1_SIZE);
19292 ++count0;
19293
19294 }
19295 if(total_item_size0*length0<column){
19296 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19297
19298 }
19299}
19300template<>
19301void 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) {
19302 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>>>>();
19303 size_t item_size0=(CYCLUS_SHA1_SIZE);
19304 size_t item_size1key=CYCLUS_SHA1_SIZE;
19305 size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19306 size_t item_size2valfirst=sizeof(double);
19307 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19308 size_t item_size3valsecondkey=sizeof(int);
19309 size_t item_size3valsecondval=sizeof(double);
19310 size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19311 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19312 size_t total_item_size0=item_size1key+item_size1val;
19313 hasher_.Clear();
19314 hasher_.Update(val0);
19315 Digest key0 = hasher_.digest();
19316 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, true);
19317 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, false);
19318 if (vlkeys_[VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE].count(key0) != 1) {
19319 hvl_t buf0 = VLValToBuf(val0);
19320 AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0);
19321 InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0, buf0);
19322 }
19323 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19324}
19325template<>
19326void Hdf5Back::WriteToBuf<MAP_INT_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19327 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19328 size_t item_size0=((sizeof(int)+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
19329 size_t length0=shape[0];
19330 size_t item_size1key=sizeof(int);
19331 size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
19332 size_t length1val=shape[2];
19333 size_t item_size2valkey=shape[3];
19334 size_t valuelen2valkey;
19335 size_t item_size2valval=sizeof(double);
19336 size_t total_item_size1val=item_size2valkey+item_size2valval;
19337 size_t total_item_size0=item_size1key+item_size1val;
19338 if(total_item_size0*val0.size()>column){
19339 std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19340 std::advance(eraseit, column/total_item_size0);
19341 val0.erase(eraseit,val0.end());
19342
19343 }
19344 unsigned int count0=0;
19345 std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19346 for(;it0!=val0.end();++it0){
19347 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19348 unsigned int count1val=0;
19349 std::map<std::string, double>::iterator it1val=it0->second.begin();
19350 for(;it1val!=it0->second.end();++it1val){
19351 valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
19352 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
19353 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
19354 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
19355 ++count1val;
19356
19357 }
19358 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19359 ++count0;
19360
19361 }
19362 if(total_item_size0*length0<column){
19363 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19364
19365 }
19366}
19367template<>
19368void Hdf5Back::WriteToBuf<MAP_INT_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19369 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19370 size_t item_size0=((sizeof(int)+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
19371 size_t length0=shape[0];
19372 size_t item_size1key=sizeof(int);
19373 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
19374 size_t length1val=shape[2];
19375 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19376 size_t item_size2valval=sizeof(double);
19377 size_t total_item_size1val=item_size2valkey+item_size2valval;
19378 size_t total_item_size0=item_size1key+item_size1val;
19379 if(total_item_size0*val0.size()>column){
19380 std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19381 std::advance(eraseit, column/total_item_size0);
19382 val0.erase(eraseit,val0.end());
19383
19384 }
19385 unsigned int count0=0;
19386 std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19387 for(;it0!=val0.end();++it0){
19388 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19389 unsigned int count1val=0;
19390 std::map<std::string, double>::iterator it1val=it0->second.begin();
19391 for(;it1val!=it0->second.end();++it1val){
19392 hasher_.Clear();
19393 hasher_.Update(it1val->first);
19394 Digest key2valkey = hasher_.digest();
19395 hid_t keysds2valkey = VLDataset(VL_STRING, true);
19396 hid_t valsds2valkey = VLDataset(VL_STRING, false);
19397 if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
19398 AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
19399 InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
19400 }
19401 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.data(), CYCLUS_SHA1_SIZE);
19402 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
19403 ++count1val;
19404
19405 }
19406 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19407 ++count0;
19408
19409 }
19410 if(total_item_size0*length0<column){
19411 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19412
19413 }
19414}
19415template<>
19416void Hdf5Back::WriteToBuf<VL_MAP_INT_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19417 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19418 size_t item_size0=(CYCLUS_SHA1_SIZE);
19419 size_t item_size1key=sizeof(int);
19420 size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
19421 size_t length1val=shape[2];
19422 size_t item_size2valkey=shape[3];
19423 size_t valuelen2valkey;
19424 size_t item_size2valval=sizeof(double);
19425 size_t total_item_size1val=item_size2valkey+item_size2valval;
19426 size_t total_item_size0=item_size1key+item_size1val;
19427 unsigned int count0=0;
19428 std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19429 std::map<int, std::map<std::string, double>> fixed_val0;
19430 unsigned int pad_count0=0;
19431 for(;it0!=val0.end();++it0){
19432 std::map<std::string, double> child1val;
19433 unsigned int pad_count1val=0;
19434 std::map<std::string, double>::iterator it1val=it0->second.begin();
19435 for(;it1val!=it0->second.end();++it1val){
19436 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
19437 child1val[child2valkey] = it1val->second;
19438 ++pad_count1val;
19439
19440 }
19441 fixed_val0[it0->first] = child1val;
19442 ++pad_count0;
19443
19444 }
19445 hasher_.Clear();
19446 hasher_.Update(fixed_val0);
19447 Digest key0 = hasher_.digest();
19448 hid_t keysds0 = VLDataset(VL_MAP_INT_MAP_STRING_DOUBLE, true);
19449 hid_t valsds0 = VLDataset(VL_MAP_INT_MAP_STRING_DOUBLE, false);
19450 if (vlkeys_[VL_MAP_INT_MAP_STRING_DOUBLE].count(key0) != 1) {
19451 hvl_t buf0 = VLValToBuf(fixed_val0);
19452 AppendVLKey(keysds0, VL_MAP_INT_MAP_STRING_DOUBLE, key0);
19453 InsertVLVal(valsds0, VL_MAP_INT_MAP_STRING_DOUBLE, key0, buf0);
19454 }
19455 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19456}
19457template<>
19458void Hdf5Back::WriteToBuf<VL_MAP_INT_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19459 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19460 size_t item_size0=(CYCLUS_SHA1_SIZE);
19461 size_t item_size1key=sizeof(int);
19462 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
19463 size_t length1val=shape[2];
19464 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19465 size_t item_size2valval=sizeof(double);
19466 size_t total_item_size1val=item_size2valkey+item_size2valval;
19467 size_t total_item_size0=item_size1key+item_size1val;
19468 unsigned int count0=0;
19469 std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19470 std::map<int, std::map<std::string, double>> fixed_val0;
19471 unsigned int pad_count0=0;
19472 for(;it0!=val0.end();++it0){
19473 std::map<std::string, double> child1val;
19474 unsigned int pad_count1val=0;
19475 std::map<std::string, double>::iterator it1val=it0->second.begin();
19476 for(;it1val!=it0->second.end();++it1val){
19477 child1val[it1val->first] = it1val->second;
19478 ++pad_count1val;
19479
19480 }
19481 fixed_val0[it0->first] = child1val;
19482 ++pad_count0;
19483
19484 }
19485 hasher_.Clear();
19486 hasher_.Update(fixed_val0);
19487 Digest key0 = hasher_.digest();
19488 hid_t keysds0 = VLDataset(VL_MAP_INT_MAP_VL_STRING_DOUBLE, true);
19489 hid_t valsds0 = VLDataset(VL_MAP_INT_MAP_VL_STRING_DOUBLE, false);
19490 if (vlkeys_[VL_MAP_INT_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
19491 hvl_t buf0 = VLValToBuf(fixed_val0);
19492 AppendVLKey(keysds0, VL_MAP_INT_MAP_VL_STRING_DOUBLE, key0);
19493 InsertVLVal(valsds0, VL_MAP_INT_MAP_VL_STRING_DOUBLE, key0, buf0);
19494 }
19495 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19496}
19497template<>
19498void Hdf5Back::WriteToBuf<MAP_INT_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19499 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19500 size_t item_size0=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
19501 size_t length0=shape[0];
19502 size_t item_size1key=sizeof(int);
19503 size_t item_size1val=(CYCLUS_SHA1_SIZE);
19504 size_t item_size2valkey=shape[3];
19505 size_t valuelen2valkey;
19506 size_t item_size2valval=sizeof(double);
19507 size_t total_item_size1val=item_size2valkey+item_size2valval;
19508 size_t total_item_size0=item_size1key+item_size1val;
19509 if(total_item_size0*val0.size()>column){
19510 std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19511 std::advance(eraseit, column/total_item_size0);
19512 val0.erase(eraseit,val0.end());
19513
19514 }
19515 unsigned int count0=0;
19516 std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19517 for(;it0!=val0.end();++it0){
19518 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19519 unsigned int count1val=0;
19520 std::map<std::string, double>::iterator it1val=it0->second.begin();
19521 std::map<std::string, double> fixed_val1val;
19522 unsigned int pad_count1val=0;
19523 for(;it1val!=it0->second.end();++it1val){
19524 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
19525 fixed_val1val[child2valkey] = it1val->second;
19526 ++pad_count1val;
19527
19528 }
19529 hasher_.Clear();
19530 hasher_.Update(fixed_val1val);
19531 Digest key1val = hasher_.digest();
19532 hid_t keysds1val = VLDataset(VL_MAP_STRING_DOUBLE, true);
19533 hid_t valsds1val = VLDataset(VL_MAP_STRING_DOUBLE, false);
19534 if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1val) != 1) {
19535 hvl_t buf1val = VLValToBuf(fixed_val1val);
19536 AppendVLKey(keysds1val, VL_MAP_STRING_DOUBLE, key1val);
19537 InsertVLVal(valsds1val, VL_MAP_STRING_DOUBLE, key1val, buf1val);
19538 }
19539 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
19540 ++count0;
19541
19542 }
19543 if(total_item_size0*length0<column){
19544 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19545
19546 }
19547}
19548template<>
19549void Hdf5Back::WriteToBuf<MAP_INT_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19550 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19551 size_t item_size0=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
19552 size_t length0=shape[0];
19553 size_t item_size1key=sizeof(int);
19554 size_t item_size1val=(CYCLUS_SHA1_SIZE);
19555 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19556 size_t item_size2valval=sizeof(double);
19557 size_t total_item_size1val=item_size2valkey+item_size2valval;
19558 size_t total_item_size0=item_size1key+item_size1val;
19559 if(total_item_size0*val0.size()>column){
19560 std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19561 std::advance(eraseit, column/total_item_size0);
19562 val0.erase(eraseit,val0.end());
19563
19564 }
19565 unsigned int count0=0;
19566 std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19567 for(;it0!=val0.end();++it0){
19568 memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19569 hasher_.Clear();
19570 hasher_.Update(it0->second);
19571 Digest key1val = hasher_.digest();
19572 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
19573 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
19574 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
19575 hvl_t buf1val = VLValToBuf(it0->second);
19576 AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
19577 InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
19578 }
19579 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
19580 ++count0;
19581
19582 }
19583 if(total_item_size0*length0<column){
19584 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19585
19586 }
19587}
19588template<>
19589void Hdf5Back::WriteToBuf<VL_MAP_INT_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19590 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19591 size_t item_size0=(CYCLUS_SHA1_SIZE);
19592 size_t item_size1key=sizeof(int);
19593 size_t item_size1val=(CYCLUS_SHA1_SIZE);
19594 size_t item_size2valkey=shape[3];
19595 size_t valuelen2valkey;
19596 size_t item_size2valval=sizeof(double);
19597 size_t total_item_size1val=item_size2valkey+item_size2valval;
19598 size_t total_item_size0=item_size1key+item_size1val;
19599 unsigned int count0=0;
19600 std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19601 std::map<int, std::map<std::string, double>> fixed_val0;
19602 unsigned int pad_count0=0;
19603 for(;it0!=val0.end();++it0){
19604 std::map<std::string, double> child1val;
19605 unsigned int pad_count1val=0;
19606 std::map<std::string, double>::iterator it1val=it0->second.begin();
19607 for(;it1val!=it0->second.end();++it1val){
19608 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
19609 child1val[child2valkey] = it1val->second;
19610 ++pad_count1val;
19611
19612 }
19613 fixed_val0[it0->first] = child1val;
19614 ++pad_count0;
19615
19616 }
19617 hasher_.Clear();
19618 hasher_.Update(fixed_val0);
19619 Digest key0 = hasher_.digest();
19620 hid_t keysds0 = VLDataset(VL_MAP_INT_VL_MAP_STRING_DOUBLE, true);
19621 hid_t valsds0 = VLDataset(VL_MAP_INT_VL_MAP_STRING_DOUBLE, false);
19622 if (vlkeys_[VL_MAP_INT_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
19623 hvl_t buf0 = VLValToBuf(fixed_val0);
19624 AppendVLKey(keysds0, VL_MAP_INT_VL_MAP_STRING_DOUBLE, key0);
19625 InsertVLVal(valsds0, VL_MAP_INT_VL_MAP_STRING_DOUBLE, key0, buf0);
19626 }
19627 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19628}
19629template<>
19630void 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) {
19631 std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19632 size_t item_size0=(CYCLUS_SHA1_SIZE);
19633 size_t item_size1key=sizeof(int);
19634 size_t item_size1val=(CYCLUS_SHA1_SIZE);
19635 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19636 size_t item_size2valval=sizeof(double);
19637 size_t total_item_size1val=item_size2valkey+item_size2valval;
19638 size_t total_item_size0=item_size1key+item_size1val;
19639 hasher_.Clear();
19640 hasher_.Update(val0);
19641 Digest key0 = hasher_.digest();
19642 hid_t keysds0 = VLDataset(VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, true);
19643 hid_t valsds0 = VLDataset(VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, false);
19644 if (vlkeys_[VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
19645 hvl_t buf0 = VLValToBuf(val0);
19646 AppendVLKey(keysds0, VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, key0);
19647 InsertVLVal(valsds0, VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
19648 }
19649 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
19650}
19651template<>
19652void 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) {
19653 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>>>>>();
19654 size_t item_size0=((shape[1]+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
19655 size_t length0=shape[0];
19656 size_t item_size1key=shape[1];
19657 size_t valuelen1key;
19658 size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
19659 size_t length1val=shape[2];
19660 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
19661 size_t item_size3valelemfirst=sizeof(int);
19662 size_t item_size3valelemsecond=((shape[6]+shape[7]));
19663 size_t item_size4valelemsecondfirst=shape[6];
19664 size_t valuelen4valelemsecondfirst;
19665 size_t item_size4valelemsecondsecond=shape[7];
19666 size_t valuelen4valelemsecondsecond;
19667 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19668 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19669 size_t total_item_size1val=item_size2valelem;
19670 size_t total_item_size0=item_size1key+item_size1val;
19671 if(total_item_size0*val0.size()>column){
19672 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19673 std::advance(eraseit, column/total_item_size0);
19674 val0.erase(eraseit,val0.end());
19675
19676 }
19677 unsigned int count0=0;
19678 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19679 for(;it0!=val0.end();++it0){
19680 valuelen1key=std::min(it0->first.size(), item_size1key);
19681 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19682 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19683 unsigned int count1val=0;
19684 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19685 for(;it1val!=it0->second.end();++it1val){
19686 unsigned int count2valelem=0;
19687 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19688 unsigned int count3valelemsecond=0;
19689 valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
19690 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);
19691 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);
19692 valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
19693 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);
19694 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);
19695 ++count1val;
19696
19697 }
19698 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19699 ++count0;
19700
19701 }
19702 if(total_item_size0*length0<column){
19703 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19704
19705 }
19706}
19707template<>
19708void 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) {
19709 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>>>>>();
19710 size_t item_size0=((shape[1]+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
19711 size_t length0=shape[0];
19712 size_t item_size1key=shape[1];
19713 size_t valuelen1key;
19714 size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
19715 size_t length1val=shape[2];
19716 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
19717 size_t item_size3valelemfirst=sizeof(int);
19718 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
19719 size_t item_size4valelemsecondfirst=shape[6];
19720 size_t valuelen4valelemsecondfirst;
19721 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
19722 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19723 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19724 size_t total_item_size1val=item_size2valelem;
19725 size_t total_item_size0=item_size1key+item_size1val;
19726 if(total_item_size0*val0.size()>column){
19727 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19728 std::advance(eraseit, column/total_item_size0);
19729 val0.erase(eraseit,val0.end());
19730
19731 }
19732 unsigned int count0=0;
19733 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19734 for(;it0!=val0.end();++it0){
19735 valuelen1key=std::min(it0->first.size(), item_size1key);
19736 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19737 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19738 unsigned int count1val=0;
19739 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19740 for(;it1val!=it0->second.end();++it1val){
19741 unsigned int count2valelem=0;
19742 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19743 unsigned int count3valelemsecond=0;
19744 valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
19745 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);
19746 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);
19747 hasher_.Clear();
19748 hasher_.Update(it1val->second.second);
19749 Digest key4valelemsecondsecond = hasher_.digest();
19750 hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
19751 hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
19752 if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
19753 AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
19754 InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
19755 }
19756 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.data(), CYCLUS_SHA1_SIZE);
19757 ++count1val;
19758
19759 }
19760 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19761 ++count0;
19762
19763 }
19764 if(total_item_size0*length0<column){
19765 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19766
19767 }
19768}
19769template<>
19770void 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) {
19771 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>>>>>();
19772 size_t item_size0=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
19773 size_t length0=shape[0];
19774 size_t item_size1key=shape[1];
19775 size_t valuelen1key;
19776 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
19777 size_t length1val=shape[2];
19778 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
19779 size_t item_size3valelemfirst=sizeof(int);
19780 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
19781 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
19782 size_t item_size4valelemsecondsecond=shape[7];
19783 size_t valuelen4valelemsecondsecond;
19784 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19785 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19786 size_t total_item_size1val=item_size2valelem;
19787 size_t total_item_size0=item_size1key+item_size1val;
19788 if(total_item_size0*val0.size()>column){
19789 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19790 std::advance(eraseit, column/total_item_size0);
19791 val0.erase(eraseit,val0.end());
19792
19793 }
19794 unsigned int count0=0;
19795 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19796 for(;it0!=val0.end();++it0){
19797 valuelen1key=std::min(it0->first.size(), item_size1key);
19798 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19799 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19800 unsigned int count1val=0;
19801 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19802 for(;it1val!=it0->second.end();++it1val){
19803 unsigned int count2valelem=0;
19804 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19805 unsigned int count3valelemsecond=0;
19806 hasher_.Clear();
19807 hasher_.Update(it1val->second.first);
19808 Digest key4valelemsecondfirst = hasher_.digest();
19809 hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
19810 hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
19811 if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
19812 AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
19813 InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
19814 }
19815 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.data(), CYCLUS_SHA1_SIZE);
19816 valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
19817 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);
19818 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);
19819 ++count1val;
19820
19821 }
19822 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19823 ++count0;
19824
19825 }
19826 if(total_item_size0*length0<column){
19827 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19828
19829 }
19830}
19831template<>
19832void 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) {
19833 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>>>>>();
19834 size_t item_size0=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
19835 size_t length0=shape[0];
19836 size_t item_size1key=shape[1];
19837 size_t valuelen1key;
19838 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
19839 size_t length1val=shape[2];
19840 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
19841 size_t item_size3valelemfirst=sizeof(int);
19842 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
19843 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
19844 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
19845 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19846 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19847 size_t total_item_size1val=item_size2valelem;
19848 size_t total_item_size0=item_size1key+item_size1val;
19849 if(total_item_size0*val0.size()>column){
19850 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19851 std::advance(eraseit, column/total_item_size0);
19852 val0.erase(eraseit,val0.end());
19853
19854 }
19855 unsigned int count0=0;
19856 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19857 for(;it0!=val0.end();++it0){
19858 valuelen1key=std::min(it0->first.size(), item_size1key);
19859 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19860 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19861 unsigned int count1val=0;
19862 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19863 for(;it1val!=it0->second.end();++it1val){
19864 unsigned int count2valelem=0;
19865 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19866 unsigned int count3valelemsecond=0;
19867 hasher_.Clear();
19868 hasher_.Update(it1val->second.first);
19869 Digest key4valelemsecondfirst = hasher_.digest();
19870 hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
19871 hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
19872 if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
19873 AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
19874 InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
19875 }
19876 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.data(), CYCLUS_SHA1_SIZE);
19877 hasher_.Clear();
19878 hasher_.Update(it1val->second.second);
19879 Digest key4valelemsecondsecond = hasher_.digest();
19880 hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
19881 hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
19882 if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
19883 AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
19884 InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
19885 }
19886 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.data(), CYCLUS_SHA1_SIZE);
19887 ++count1val;
19888
19889 }
19890 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19891 ++count0;
19892
19893 }
19894 if(total_item_size0*length0<column){
19895 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19896
19897 }
19898}
19899template<>
19900void 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) {
19901 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>>>>>();
19902 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
19903 size_t length0=shape[0];
19904 size_t item_size1key=shape[1];
19905 size_t valuelen1key;
19906 size_t item_size1val=(CYCLUS_SHA1_SIZE);
19907 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
19908 size_t item_size3valelemfirst=sizeof(int);
19909 size_t item_size3valelemsecond=((shape[6]+shape[7]));
19910 size_t item_size4valelemsecondfirst=shape[6];
19911 size_t valuelen4valelemsecondfirst;
19912 size_t item_size4valelemsecondsecond=shape[7];
19913 size_t valuelen4valelemsecondsecond;
19914 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19915 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19916 size_t total_item_size1val=item_size2valelem;
19917 size_t total_item_size0=item_size1key+item_size1val;
19918 if(total_item_size0*val0.size()>column){
19919 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19920 std::advance(eraseit, column/total_item_size0);
19921 val0.erase(eraseit,val0.end());
19922
19923 }
19924 unsigned int count0=0;
19925 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19926 for(;it0!=val0.end();++it0){
19927 valuelen1key=std::min(it0->first.size(), item_size1key);
19928 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19929 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19930 unsigned int count1val=0;
19931 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19932 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
19933 unsigned int pad_count1val=0;
19934 for(;it1val!=it0->second.end();++it1val){
19935 std::pair<int, std::pair<std::string, std::string>> child2valelem;
19936 unsigned int pad_count2valelem=0;
19937 std::pair<std::string, std::string> child3valelemsecond;
19938 unsigned int pad_count3valelemsecond=0;
19939 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
19940 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
19941 child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
19942 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
19943 fixed_val1val.push_back(child2valelem);
19944 ++pad_count1val;
19945
19946 }
19947 hasher_.Clear();
19948 hasher_.Update(fixed_val1val);
19949 Digest key1val = hasher_.digest();
19950 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
19951 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
19952 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key1val) != 1) {
19953 hvl_t buf1val = VLValToBuf(fixed_val1val);
19954 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val);
19955 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val, buf1val);
19956 }
19957 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
19958 ++count0;
19959
19960 }
19961 if(total_item_size0*length0<column){
19962 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19963
19964 }
19965}
19966template<>
19967void 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) {
19968 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>>>>>();
19969 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
19970 size_t length0=shape[0];
19971 size_t item_size1key=shape[1];
19972 size_t valuelen1key;
19973 size_t item_size1val=(CYCLUS_SHA1_SIZE);
19974 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
19975 size_t item_size3valelemfirst=sizeof(int);
19976 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
19977 size_t item_size4valelemsecondfirst=shape[6];
19978 size_t valuelen4valelemsecondfirst;
19979 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
19980 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19981 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19982 size_t total_item_size1val=item_size2valelem;
19983 size_t total_item_size0=item_size1key+item_size1val;
19984 if(total_item_size0*val0.size()>column){
19985 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19986 std::advance(eraseit, column/total_item_size0);
19987 val0.erase(eraseit,val0.end());
19988
19989 }
19990 unsigned int count0=0;
19991 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19992 for(;it0!=val0.end();++it0){
19993 valuelen1key=std::min(it0->first.size(), item_size1key);
19994 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19995 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19996 unsigned int count1val=0;
19997 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19998 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
19999 unsigned int pad_count1val=0;
20000 for(;it1val!=it0->second.end();++it1val){
20001 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20002 unsigned int pad_count2valelem=0;
20003 std::pair<std::string, std::string> child3valelemsecond;
20004 unsigned int pad_count3valelemsecond=0;
20005 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20006 child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
20007 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20008 fixed_val1val.push_back(child2valelem);
20009 ++pad_count1val;
20010
20011 }
20012 hasher_.Clear();
20013 hasher_.Update(fixed_val1val);
20014 Digest key1val = hasher_.digest();
20015 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
20016 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
20017 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key1val) != 1) {
20018 hvl_t buf1val = VLValToBuf(fixed_val1val);
20019 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val);
20020 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val, buf1val);
20021 }
20022 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
20023 ++count0;
20024
20025 }
20026 if(total_item_size0*length0<column){
20027 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20028
20029 }
20030}
20031template<>
20032void 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) {
20033 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>>>>>();
20034 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
20035 size_t length0=shape[0];
20036 size_t item_size1key=shape[1];
20037 size_t valuelen1key;
20038 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20039 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20040 size_t item_size3valelemfirst=sizeof(int);
20041 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20042 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20043 size_t item_size4valelemsecondsecond=shape[7];
20044 size_t valuelen4valelemsecondsecond;
20045 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20046 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20047 size_t total_item_size1val=item_size2valelem;
20048 size_t total_item_size0=item_size1key+item_size1val;
20049 if(total_item_size0*val0.size()>column){
20050 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20051 std::advance(eraseit, column/total_item_size0);
20052 val0.erase(eraseit,val0.end());
20053
20054 }
20055 unsigned int count0=0;
20056 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20057 for(;it0!=val0.end();++it0){
20058 valuelen1key=std::min(it0->first.size(), item_size1key);
20059 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
20060 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
20061 unsigned int count1val=0;
20062 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20063 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20064 unsigned int pad_count1val=0;
20065 for(;it1val!=it0->second.end();++it1val){
20066 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20067 unsigned int pad_count2valelem=0;
20068 std::pair<std::string, std::string> child3valelemsecond;
20069 unsigned int pad_count3valelemsecond=0;
20070 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20071 child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
20072 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20073 fixed_val1val.push_back(child2valelem);
20074 ++pad_count1val;
20075
20076 }
20077 hasher_.Clear();
20078 hasher_.Update(fixed_val1val);
20079 Digest key1val = hasher_.digest();
20080 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
20081 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
20082 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key1val) != 1) {
20083 hvl_t buf1val = VLValToBuf(fixed_val1val);
20084 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val);
20085 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val, buf1val);
20086 }
20087 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
20088 ++count0;
20089
20090 }
20091 if(total_item_size0*length0<column){
20092 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20093
20094 }
20095}
20096template<>
20097void 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) {
20098 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>>>>>();
20099 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
20100 size_t length0=shape[0];
20101 size_t item_size1key=shape[1];
20102 size_t valuelen1key;
20103 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20104 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20105 size_t item_size3valelemfirst=sizeof(int);
20106 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20107 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20108 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20109 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20110 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20111 size_t total_item_size1val=item_size2valelem;
20112 size_t total_item_size0=item_size1key+item_size1val;
20113 if(total_item_size0*val0.size()>column){
20114 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20115 std::advance(eraseit, column/total_item_size0);
20116 val0.erase(eraseit,val0.end());
20117
20118 }
20119 unsigned int count0=0;
20120 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20121 for(;it0!=val0.end();++it0){
20122 valuelen1key=std::min(it0->first.size(), item_size1key);
20123 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
20124 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
20125 hasher_.Clear();
20126 hasher_.Update(it0->second);
20127 Digest key1val = hasher_.digest();
20128 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
20129 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
20130 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key1val) != 1) {
20131 hvl_t buf1val = VLValToBuf(it0->second);
20132 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val);
20133 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val, buf1val);
20134 }
20135 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
20136 ++count0;
20137
20138 }
20139 if(total_item_size0*length0<column){
20140 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20141
20142 }
20143}
20144template<>
20145void 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) {
20146 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>>>>>();
20147 size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
20148 size_t length0=shape[0];
20149 size_t item_size1key=CYCLUS_SHA1_SIZE;
20150 size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
20151 size_t length1val=shape[2];
20152 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20153 size_t item_size3valelemfirst=sizeof(int);
20154 size_t item_size3valelemsecond=((shape[6]+shape[7]));
20155 size_t item_size4valelemsecondfirst=shape[6];
20156 size_t valuelen4valelemsecondfirst;
20157 size_t item_size4valelemsecondsecond=shape[7];
20158 size_t valuelen4valelemsecondsecond;
20159 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20160 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20161 size_t total_item_size1val=item_size2valelem;
20162 size_t total_item_size0=item_size1key+item_size1val;
20163 if(total_item_size0*val0.size()>column){
20164 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20165 std::advance(eraseit, column/total_item_size0);
20166 val0.erase(eraseit,val0.end());
20167
20168 }
20169 unsigned int count0=0;
20170 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20171 for(;it0!=val0.end();++it0){
20172 hasher_.Clear();
20173 hasher_.Update(it0->first);
20174 Digest key1key = hasher_.digest();
20175 hid_t keysds1key = VLDataset(VL_STRING, true);
20176 hid_t valsds1key = VLDataset(VL_STRING, false);
20177 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20178 AppendVLKey(keysds1key, VL_STRING, key1key);
20179 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20180 }
20181 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20182 unsigned int count1val=0;
20183 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20184 for(;it1val!=it0->second.end();++it1val){
20185 unsigned int count2valelem=0;
20186 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20187 unsigned int count3valelemsecond=0;
20188 valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
20189 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);
20190 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);
20191 valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
20192 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);
20193 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);
20194 ++count1val;
20195
20196 }
20197 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20198 ++count0;
20199
20200 }
20201 if(total_item_size0*length0<column){
20202 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20203
20204 }
20205}
20206template<>
20207void 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) {
20208 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>>>>>();
20209 size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
20210 size_t length0=shape[0];
20211 size_t item_size1key=CYCLUS_SHA1_SIZE;
20212 size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
20213 size_t length1val=shape[2];
20214 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20215 size_t item_size3valelemfirst=sizeof(int);
20216 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20217 size_t item_size4valelemsecondfirst=shape[6];
20218 size_t valuelen4valelemsecondfirst;
20219 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20220 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20221 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20222 size_t total_item_size1val=item_size2valelem;
20223 size_t total_item_size0=item_size1key+item_size1val;
20224 if(total_item_size0*val0.size()>column){
20225 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20226 std::advance(eraseit, column/total_item_size0);
20227 val0.erase(eraseit,val0.end());
20228
20229 }
20230 unsigned int count0=0;
20231 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20232 for(;it0!=val0.end();++it0){
20233 hasher_.Clear();
20234 hasher_.Update(it0->first);
20235 Digest key1key = hasher_.digest();
20236 hid_t keysds1key = VLDataset(VL_STRING, true);
20237 hid_t valsds1key = VLDataset(VL_STRING, false);
20238 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20239 AppendVLKey(keysds1key, VL_STRING, key1key);
20240 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20241 }
20242 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20243 unsigned int count1val=0;
20244 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20245 for(;it1val!=it0->second.end();++it1val){
20246 unsigned int count2valelem=0;
20247 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20248 unsigned int count3valelemsecond=0;
20249 valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
20250 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);
20251 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);
20252 hasher_.Clear();
20253 hasher_.Update(it1val->second.second);
20254 Digest key4valelemsecondsecond = hasher_.digest();
20255 hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
20256 hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
20257 if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
20258 AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
20259 InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
20260 }
20261 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.data(), CYCLUS_SHA1_SIZE);
20262 ++count1val;
20263
20264 }
20265 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20266 ++count0;
20267
20268 }
20269 if(total_item_size0*length0<column){
20270 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20271
20272 }
20273}
20274template<>
20275void 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) {
20276 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>>>>>();
20277 size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
20278 size_t length0=shape[0];
20279 size_t item_size1key=CYCLUS_SHA1_SIZE;
20280 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
20281 size_t length1val=shape[2];
20282 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20283 size_t item_size3valelemfirst=sizeof(int);
20284 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20285 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20286 size_t item_size4valelemsecondsecond=shape[7];
20287 size_t valuelen4valelemsecondsecond;
20288 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20289 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20290 size_t total_item_size1val=item_size2valelem;
20291 size_t total_item_size0=item_size1key+item_size1val;
20292 if(total_item_size0*val0.size()>column){
20293 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20294 std::advance(eraseit, column/total_item_size0);
20295 val0.erase(eraseit,val0.end());
20296
20297 }
20298 unsigned int count0=0;
20299 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20300 for(;it0!=val0.end();++it0){
20301 hasher_.Clear();
20302 hasher_.Update(it0->first);
20303 Digest key1key = hasher_.digest();
20304 hid_t keysds1key = VLDataset(VL_STRING, true);
20305 hid_t valsds1key = VLDataset(VL_STRING, false);
20306 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20307 AppendVLKey(keysds1key, VL_STRING, key1key);
20308 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20309 }
20310 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20311 unsigned int count1val=0;
20312 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20313 for(;it1val!=it0->second.end();++it1val){
20314 unsigned int count2valelem=0;
20315 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20316 unsigned int count3valelemsecond=0;
20317 hasher_.Clear();
20318 hasher_.Update(it1val->second.first);
20319 Digest key4valelemsecondfirst = hasher_.digest();
20320 hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
20321 hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
20322 if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
20323 AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
20324 InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
20325 }
20326 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.data(), CYCLUS_SHA1_SIZE);
20327 valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
20328 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);
20329 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);
20330 ++count1val;
20331
20332 }
20333 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20334 ++count0;
20335
20336 }
20337 if(total_item_size0*length0<column){
20338 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20339
20340 }
20341}
20342template<>
20343void 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) {
20344 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>>>>>();
20345 size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
20346 size_t length0=shape[0];
20347 size_t item_size1key=CYCLUS_SHA1_SIZE;
20348 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
20349 size_t length1val=shape[2];
20350 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20351 size_t item_size3valelemfirst=sizeof(int);
20352 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20353 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20354 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20355 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20356 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20357 size_t total_item_size1val=item_size2valelem;
20358 size_t total_item_size0=item_size1key+item_size1val;
20359 if(total_item_size0*val0.size()>column){
20360 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20361 std::advance(eraseit, column/total_item_size0);
20362 val0.erase(eraseit,val0.end());
20363
20364 }
20365 unsigned int count0=0;
20366 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20367 for(;it0!=val0.end();++it0){
20368 hasher_.Clear();
20369 hasher_.Update(it0->first);
20370 Digest key1key = hasher_.digest();
20371 hid_t keysds1key = VLDataset(VL_STRING, true);
20372 hid_t valsds1key = VLDataset(VL_STRING, false);
20373 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20374 AppendVLKey(keysds1key, VL_STRING, key1key);
20375 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20376 }
20377 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20378 unsigned int count1val=0;
20379 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20380 for(;it1val!=it0->second.end();++it1val){
20381 unsigned int count2valelem=0;
20382 memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20383 unsigned int count3valelemsecond=0;
20384 hasher_.Clear();
20385 hasher_.Update(it1val->second.first);
20386 Digest key4valelemsecondfirst = hasher_.digest();
20387 hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
20388 hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
20389 if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
20390 AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
20391 InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
20392 }
20393 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.data(), CYCLUS_SHA1_SIZE);
20394 hasher_.Clear();
20395 hasher_.Update(it1val->second.second);
20396 Digest key4valelemsecondsecond = hasher_.digest();
20397 hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
20398 hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
20399 if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
20400 AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
20401 InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
20402 }
20403 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.data(), CYCLUS_SHA1_SIZE);
20404 ++count1val;
20405
20406 }
20407 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20408 ++count0;
20409
20410 }
20411 if(total_item_size0*length0<column){
20412 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20413
20414 }
20415}
20416template<>
20417void 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) {
20418 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>>>>>();
20419 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20420 size_t length0=shape[0];
20421 size_t item_size1key=CYCLUS_SHA1_SIZE;
20422 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20423 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20424 size_t item_size3valelemfirst=sizeof(int);
20425 size_t item_size3valelemsecond=((shape[6]+shape[7]));
20426 size_t item_size4valelemsecondfirst=shape[6];
20427 size_t valuelen4valelemsecondfirst;
20428 size_t item_size4valelemsecondsecond=shape[7];
20429 size_t valuelen4valelemsecondsecond;
20430 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20431 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20432 size_t total_item_size1val=item_size2valelem;
20433 size_t total_item_size0=item_size1key+item_size1val;
20434 if(total_item_size0*val0.size()>column){
20435 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20436 std::advance(eraseit, column/total_item_size0);
20437 val0.erase(eraseit,val0.end());
20438
20439 }
20440 unsigned int count0=0;
20441 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20442 for(;it0!=val0.end();++it0){
20443 hasher_.Clear();
20444 hasher_.Update(it0->first);
20445 Digest key1key = hasher_.digest();
20446 hid_t keysds1key = VLDataset(VL_STRING, true);
20447 hid_t valsds1key = VLDataset(VL_STRING, false);
20448 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20449 AppendVLKey(keysds1key, VL_STRING, key1key);
20450 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20451 }
20452 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20453 unsigned int count1val=0;
20454 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20455 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20456 unsigned int pad_count1val=0;
20457 for(;it1val!=it0->second.end();++it1val){
20458 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20459 unsigned int pad_count2valelem=0;
20460 std::pair<std::string, std::string> child3valelemsecond;
20461 unsigned int pad_count3valelemsecond=0;
20462 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20463 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20464 child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
20465 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20466 fixed_val1val.push_back(child2valelem);
20467 ++pad_count1val;
20468
20469 }
20470 hasher_.Clear();
20471 hasher_.Update(fixed_val1val);
20472 Digest key1val = hasher_.digest();
20473 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
20474 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
20475 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key1val) != 1) {
20476 hvl_t buf1val = VLValToBuf(fixed_val1val);
20477 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val);
20478 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val, buf1val);
20479 }
20480 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
20481 ++count0;
20482
20483 }
20484 if(total_item_size0*length0<column){
20485 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20486
20487 }
20488}
20489template<>
20490void 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) {
20491 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>>>>>();
20492 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20493 size_t length0=shape[0];
20494 size_t item_size1key=CYCLUS_SHA1_SIZE;
20495 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20496 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20497 size_t item_size3valelemfirst=sizeof(int);
20498 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20499 size_t item_size4valelemsecondfirst=shape[6];
20500 size_t valuelen4valelemsecondfirst;
20501 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20502 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20503 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20504 size_t total_item_size1val=item_size2valelem;
20505 size_t total_item_size0=item_size1key+item_size1val;
20506 if(total_item_size0*val0.size()>column){
20507 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20508 std::advance(eraseit, column/total_item_size0);
20509 val0.erase(eraseit,val0.end());
20510
20511 }
20512 unsigned int count0=0;
20513 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20514 for(;it0!=val0.end();++it0){
20515 hasher_.Clear();
20516 hasher_.Update(it0->first);
20517 Digest key1key = hasher_.digest();
20518 hid_t keysds1key = VLDataset(VL_STRING, true);
20519 hid_t valsds1key = VLDataset(VL_STRING, false);
20520 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20521 AppendVLKey(keysds1key, VL_STRING, key1key);
20522 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20523 }
20524 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20525 unsigned int count1val=0;
20526 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20527 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20528 unsigned int pad_count1val=0;
20529 for(;it1val!=it0->second.end();++it1val){
20530 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20531 unsigned int pad_count2valelem=0;
20532 std::pair<std::string, std::string> child3valelemsecond;
20533 unsigned int pad_count3valelemsecond=0;
20534 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20535 child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
20536 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20537 fixed_val1val.push_back(child2valelem);
20538 ++pad_count1val;
20539
20540 }
20541 hasher_.Clear();
20542 hasher_.Update(fixed_val1val);
20543 Digest key1val = hasher_.digest();
20544 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
20545 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
20546 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key1val) != 1) {
20547 hvl_t buf1val = VLValToBuf(fixed_val1val);
20548 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val);
20549 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val, buf1val);
20550 }
20551 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
20552 ++count0;
20553
20554 }
20555 if(total_item_size0*length0<column){
20556 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20557
20558 }
20559}
20560template<>
20561void 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) {
20562 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>>>>>();
20563 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20564 size_t length0=shape[0];
20565 size_t item_size1key=CYCLUS_SHA1_SIZE;
20566 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20567 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20568 size_t item_size3valelemfirst=sizeof(int);
20569 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20570 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20571 size_t item_size4valelemsecondsecond=shape[7];
20572 size_t valuelen4valelemsecondsecond;
20573 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20574 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20575 size_t total_item_size1val=item_size2valelem;
20576 size_t total_item_size0=item_size1key+item_size1val;
20577 if(total_item_size0*val0.size()>column){
20578 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20579 std::advance(eraseit, column/total_item_size0);
20580 val0.erase(eraseit,val0.end());
20581
20582 }
20583 unsigned int count0=0;
20584 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20585 for(;it0!=val0.end();++it0){
20586 hasher_.Clear();
20587 hasher_.Update(it0->first);
20588 Digest key1key = hasher_.digest();
20589 hid_t keysds1key = VLDataset(VL_STRING, true);
20590 hid_t valsds1key = VLDataset(VL_STRING, false);
20591 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20592 AppendVLKey(keysds1key, VL_STRING, key1key);
20593 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20594 }
20595 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20596 unsigned int count1val=0;
20597 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20598 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20599 unsigned int pad_count1val=0;
20600 for(;it1val!=it0->second.end();++it1val){
20601 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20602 unsigned int pad_count2valelem=0;
20603 std::pair<std::string, std::string> child3valelemsecond;
20604 unsigned int pad_count3valelemsecond=0;
20605 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20606 child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
20607 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20608 fixed_val1val.push_back(child2valelem);
20609 ++pad_count1val;
20610
20611 }
20612 hasher_.Clear();
20613 hasher_.Update(fixed_val1val);
20614 Digest key1val = hasher_.digest();
20615 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
20616 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
20617 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key1val) != 1) {
20618 hvl_t buf1val = VLValToBuf(fixed_val1val);
20619 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val);
20620 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val, buf1val);
20621 }
20622 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
20623 ++count0;
20624
20625 }
20626 if(total_item_size0*length0<column){
20627 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20628
20629 }
20630}
20631template<>
20632void 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) {
20633 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>>>>>();
20634 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20635 size_t length0=shape[0];
20636 size_t item_size1key=CYCLUS_SHA1_SIZE;
20637 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20638 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20639 size_t item_size3valelemfirst=sizeof(int);
20640 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20641 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20642 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20643 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20644 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20645 size_t total_item_size1val=item_size2valelem;
20646 size_t total_item_size0=item_size1key+item_size1val;
20647 if(total_item_size0*val0.size()>column){
20648 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20649 std::advance(eraseit, column/total_item_size0);
20650 val0.erase(eraseit,val0.end());
20651
20652 }
20653 unsigned int count0=0;
20654 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20655 for(;it0!=val0.end();++it0){
20656 hasher_.Clear();
20657 hasher_.Update(it0->first);
20658 Digest key1key = hasher_.digest();
20659 hid_t keysds1key = VLDataset(VL_STRING, true);
20660 hid_t valsds1key = VLDataset(VL_STRING, false);
20661 if (vlkeys_[VL_STRING].count(key1key) != 1) {
20662 AppendVLKey(keysds1key, VL_STRING, key1key);
20663 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20664 }
20665 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
20666 hasher_.Clear();
20667 hasher_.Update(it0->second);
20668 Digest key1val = hasher_.digest();
20669 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
20670 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
20671 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key1val) != 1) {
20672 hvl_t buf1val = VLValToBuf(it0->second);
20673 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val);
20674 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val, buf1val);
20675 }
20676 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
20677 ++count0;
20678
20679 }
20680 if(total_item_size0*length0<column){
20681 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20682
20683 }
20684}
20685template<>
20686void 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) {
20687 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>>>>>();
20688 size_t item_size0=(CYCLUS_SHA1_SIZE);
20689 size_t item_size1key=shape[1];
20690 size_t valuelen1key;
20691 size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
20692 size_t length1val=shape[2];
20693 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20694 size_t item_size3valelemfirst=sizeof(int);
20695 size_t item_size3valelemsecond=((shape[6]+shape[7]));
20696 size_t item_size4valelemsecondfirst=shape[6];
20697 size_t valuelen4valelemsecondfirst;
20698 size_t item_size4valelemsecondsecond=shape[7];
20699 size_t valuelen4valelemsecondsecond;
20700 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20701 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20702 size_t total_item_size1val=item_size2valelem;
20703 size_t total_item_size0=item_size1key+item_size1val;
20704 unsigned int count0=0;
20705 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20706 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20707 unsigned int pad_count0=0;
20708 for(;it0!=val0.end();++it0){
20709 std::string child1key=std::string(it0->first,0,item_size1key);
20710 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20711 unsigned int pad_count1val=0;
20712 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20713 for(;it1val!=it0->second.end();++it1val){
20714 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20715 unsigned int pad_count2valelem=0;
20716 std::pair<std::string, std::string> child3valelemsecond;
20717 unsigned int pad_count3valelemsecond=0;
20718 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20719 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20720 child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
20721 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20722 child1val.push_back(child2valelem);
20723 ++pad_count1val;
20724
20725 }
20726 child1val.resize(length1val);
20727 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20728 fixed_val0[child1key] = child1val;
20729 ++pad_count0;
20730
20731 }
20732 hasher_.Clear();
20733 hasher_.Update(fixed_val0);
20734 Digest key0 = hasher_.digest();
20735 hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
20736 hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
20737 if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
20738 hvl_t buf0 = VLValToBuf(fixed_val0);
20739 AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
20740 InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
20741 }
20742 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
20743}
20744template<>
20745void 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) {
20746 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>>>>>();
20747 size_t item_size0=(CYCLUS_SHA1_SIZE);
20748 size_t item_size1key=shape[1];
20749 size_t valuelen1key;
20750 size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
20751 size_t length1val=shape[2];
20752 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20753 size_t item_size3valelemfirst=sizeof(int);
20754 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20755 size_t item_size4valelemsecondfirst=shape[6];
20756 size_t valuelen4valelemsecondfirst;
20757 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20758 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20759 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20760 size_t total_item_size1val=item_size2valelem;
20761 size_t total_item_size0=item_size1key+item_size1val;
20762 unsigned int count0=0;
20763 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20764 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20765 unsigned int pad_count0=0;
20766 for(;it0!=val0.end();++it0){
20767 std::string child1key=std::string(it0->first,0,item_size1key);
20768 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20769 unsigned int pad_count1val=0;
20770 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20771 for(;it1val!=it0->second.end();++it1val){
20772 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20773 unsigned int pad_count2valelem=0;
20774 std::pair<std::string, std::string> child3valelemsecond;
20775 unsigned int pad_count3valelemsecond=0;
20776 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20777 child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
20778 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20779 child1val.push_back(child2valelem);
20780 ++pad_count1val;
20781
20782 }
20783 child1val.resize(length1val);
20784 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20785 fixed_val0[child1key] = child1val;
20786 ++pad_count0;
20787
20788 }
20789 hasher_.Clear();
20790 hasher_.Update(fixed_val0);
20791 Digest key0 = hasher_.digest();
20792 hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
20793 hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
20794 if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
20795 hvl_t buf0 = VLValToBuf(fixed_val0);
20796 AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
20797 InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
20798 }
20799 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
20800}
20801template<>
20802void 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) {
20803 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>>>>>();
20804 size_t item_size0=(CYCLUS_SHA1_SIZE);
20805 size_t item_size1key=shape[1];
20806 size_t valuelen1key;
20807 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
20808 size_t length1val=shape[2];
20809 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20810 size_t item_size3valelemfirst=sizeof(int);
20811 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20812 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20813 size_t item_size4valelemsecondsecond=shape[7];
20814 size_t valuelen4valelemsecondsecond;
20815 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20816 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20817 size_t total_item_size1val=item_size2valelem;
20818 size_t total_item_size0=item_size1key+item_size1val;
20819 unsigned int count0=0;
20820 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20821 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20822 unsigned int pad_count0=0;
20823 for(;it0!=val0.end();++it0){
20824 std::string child1key=std::string(it0->first,0,item_size1key);
20825 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20826 unsigned int pad_count1val=0;
20827 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20828 for(;it1val!=it0->second.end();++it1val){
20829 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20830 unsigned int pad_count2valelem=0;
20831 std::pair<std::string, std::string> child3valelemsecond;
20832 unsigned int pad_count3valelemsecond=0;
20833 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20834 child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
20835 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20836 child1val.push_back(child2valelem);
20837 ++pad_count1val;
20838
20839 }
20840 child1val.resize(length1val);
20841 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20842 fixed_val0[child1key] = child1val;
20843 ++pad_count0;
20844
20845 }
20846 hasher_.Clear();
20847 hasher_.Update(fixed_val0);
20848 Digest key0 = hasher_.digest();
20849 hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
20850 hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
20851 if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
20852 hvl_t buf0 = VLValToBuf(fixed_val0);
20853 AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
20854 InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
20855 }
20856 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
20857}
20858template<>
20859void 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) {
20860 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>>>>>();
20861 size_t item_size0=(CYCLUS_SHA1_SIZE);
20862 size_t item_size1key=shape[1];
20863 size_t valuelen1key;
20864 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
20865 size_t length1val=shape[2];
20866 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20867 size_t item_size3valelemfirst=sizeof(int);
20868 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20869 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20870 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20871 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20872 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20873 size_t total_item_size1val=item_size2valelem;
20874 size_t total_item_size0=item_size1key+item_size1val;
20875 unsigned int count0=0;
20876 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20877 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20878 unsigned int pad_count0=0;
20879 for(;it0!=val0.end();++it0){
20880 std::string child1key=std::string(it0->first,0,item_size1key);
20881 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20882 unsigned int pad_count1val=0;
20883 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20884 for(;it1val!=it0->second.end();++it1val){
20885 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20886 unsigned int pad_count2valelem=0;
20887 std::pair<std::string, std::string> child3valelemsecond;
20888 unsigned int pad_count3valelemsecond=0;
20889 child3valelemsecond = std::make_pair((*it1val).second.first,(*it1val).second.second);
20890 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20891 child1val.push_back(child2valelem);
20892 ++pad_count1val;
20893
20894 }
20895 child1val.resize(length1val);
20896 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20897 fixed_val0[child1key] = child1val;
20898 ++pad_count0;
20899
20900 }
20901 hasher_.Clear();
20902 hasher_.Update(fixed_val0);
20903 Digest key0 = hasher_.digest();
20904 hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
20905 hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
20906 if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
20907 hvl_t buf0 = VLValToBuf(fixed_val0);
20908 AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0);
20909 InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
20910 }
20911 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
20912}
20913template<>
20914void 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) {
20915 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>>>>>();
20916 size_t item_size0=(CYCLUS_SHA1_SIZE);
20917 size_t item_size1key=shape[1];
20918 size_t valuelen1key;
20919 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20920 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20921 size_t item_size3valelemfirst=sizeof(int);
20922 size_t item_size3valelemsecond=((shape[6]+shape[7]));
20923 size_t item_size4valelemsecondfirst=shape[6];
20924 size_t valuelen4valelemsecondfirst;
20925 size_t item_size4valelemsecondsecond=shape[7];
20926 size_t valuelen4valelemsecondsecond;
20927 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20928 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20929 size_t total_item_size1val=item_size2valelem;
20930 size_t total_item_size0=item_size1key+item_size1val;
20931 unsigned int count0=0;
20932 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20933 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20934 unsigned int pad_count0=0;
20935 for(;it0!=val0.end();++it0){
20936 std::string child1key=std::string(it0->first,0,item_size1key);
20937 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20938 unsigned int pad_count1val=0;
20939 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20940 for(;it1val!=it0->second.end();++it1val){
20941 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20942 unsigned int pad_count2valelem=0;
20943 std::pair<std::string, std::string> child3valelemsecond;
20944 unsigned int pad_count3valelemsecond=0;
20945 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20946 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20947 child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
20948 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20949 child1val.push_back(child2valelem);
20950 ++pad_count1val;
20951
20952 }
20953 fixed_val0[child1key] = child1val;
20954 ++pad_count0;
20955
20956 }
20957 hasher_.Clear();
20958 hasher_.Update(fixed_val0);
20959 Digest key0 = hasher_.digest();
20960 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
20961 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
20962 if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
20963 hvl_t buf0 = VLValToBuf(fixed_val0);
20964 AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
20965 InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
20966 }
20967 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
20968}
20969template<>
20970void 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) {
20971 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>>>>>();
20972 size_t item_size0=(CYCLUS_SHA1_SIZE);
20973 size_t item_size1key=shape[1];
20974 size_t valuelen1key;
20975 size_t item_size1val=(CYCLUS_SHA1_SIZE);
20976 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20977 size_t item_size3valelemfirst=sizeof(int);
20978 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20979 size_t item_size4valelemsecondfirst=shape[6];
20980 size_t valuelen4valelemsecondfirst;
20981 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20982 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20983 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20984 size_t total_item_size1val=item_size2valelem;
20985 size_t total_item_size0=item_size1key+item_size1val;
20986 unsigned int count0=0;
20987 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20988 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20989 unsigned int pad_count0=0;
20990 for(;it0!=val0.end();++it0){
20991 std::string child1key=std::string(it0->first,0,item_size1key);
20992 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20993 unsigned int pad_count1val=0;
20994 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20995 for(;it1val!=it0->second.end();++it1val){
20996 std::pair<int, std::pair<std::string, std::string>> child2valelem;
20997 unsigned int pad_count2valelem=0;
20998 std::pair<std::string, std::string> child3valelemsecond;
20999 unsigned int pad_count3valelemsecond=0;
21000 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21001 child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
21002 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21003 child1val.push_back(child2valelem);
21004 ++pad_count1val;
21005
21006 }
21007 fixed_val0[child1key] = child1val;
21008 ++pad_count0;
21009
21010 }
21011 hasher_.Clear();
21012 hasher_.Update(fixed_val0);
21013 Digest key0 = hasher_.digest();
21014 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
21015 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
21016 if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
21017 hvl_t buf0 = VLValToBuf(fixed_val0);
21018 AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
21019 InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
21020 }
21021 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21022}
21023template<>
21024void 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) {
21025 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>>>>>();
21026 size_t item_size0=(CYCLUS_SHA1_SIZE);
21027 size_t item_size1key=shape[1];
21028 size_t valuelen1key;
21029 size_t item_size1val=(CYCLUS_SHA1_SIZE);
21030 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
21031 size_t item_size3valelemfirst=sizeof(int);
21032 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
21033 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21034 size_t item_size4valelemsecondsecond=shape[7];
21035 size_t valuelen4valelemsecondsecond;
21036 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21037 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21038 size_t total_item_size1val=item_size2valelem;
21039 size_t total_item_size0=item_size1key+item_size1val;
21040 unsigned int count0=0;
21041 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21042 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21043 unsigned int pad_count0=0;
21044 for(;it0!=val0.end();++it0){
21045 std::string child1key=std::string(it0->first,0,item_size1key);
21046 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21047 unsigned int pad_count1val=0;
21048 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21049 for(;it1val!=it0->second.end();++it1val){
21050 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21051 unsigned int pad_count2valelem=0;
21052 std::pair<std::string, std::string> child3valelemsecond;
21053 unsigned int pad_count3valelemsecond=0;
21054 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21055 child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
21056 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21057 child1val.push_back(child2valelem);
21058 ++pad_count1val;
21059
21060 }
21061 fixed_val0[child1key] = child1val;
21062 ++pad_count0;
21063
21064 }
21065 hasher_.Clear();
21066 hasher_.Update(fixed_val0);
21067 Digest key0 = hasher_.digest();
21068 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
21069 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
21070 if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
21071 hvl_t buf0 = VLValToBuf(fixed_val0);
21072 AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
21073 InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
21074 }
21075 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21076}
21077template<>
21078void 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) {
21079 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>>>>>();
21080 size_t item_size0=(CYCLUS_SHA1_SIZE);
21081 size_t item_size1key=shape[1];
21082 size_t valuelen1key;
21083 size_t item_size1val=(CYCLUS_SHA1_SIZE);
21084 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
21085 size_t item_size3valelemfirst=sizeof(int);
21086 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
21087 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21088 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21089 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21090 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21091 size_t total_item_size1val=item_size2valelem;
21092 size_t total_item_size0=item_size1key+item_size1val;
21093 unsigned int count0=0;
21094 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21095 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21096 unsigned int pad_count0=0;
21097 for(;it0!=val0.end();++it0){
21098 std::string child1key=std::string(it0->first,0,item_size1key);
21099 fixed_val0[child1key] = it0->second;
21100 ++pad_count0;
21101
21102 }
21103 hasher_.Clear();
21104 hasher_.Update(fixed_val0);
21105 Digest key0 = hasher_.digest();
21106 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
21107 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
21108 if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
21109 hvl_t buf0 = VLValToBuf(fixed_val0);
21110 AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0);
21111 InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
21112 }
21113 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21114}
21115template<>
21116void 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) {
21117 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>>>>>();
21118 size_t item_size0=(CYCLUS_SHA1_SIZE);
21119 size_t item_size1key=CYCLUS_SHA1_SIZE;
21120 size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
21121 size_t length1val=shape[2];
21122 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
21123 size_t item_size3valelemfirst=sizeof(int);
21124 size_t item_size3valelemsecond=((shape[6]+shape[7]));
21125 size_t item_size4valelemsecondfirst=shape[6];
21126 size_t valuelen4valelemsecondfirst;
21127 size_t item_size4valelemsecondsecond=shape[7];
21128 size_t valuelen4valelemsecondsecond;
21129 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21130 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21131 size_t total_item_size1val=item_size2valelem;
21132 size_t total_item_size0=item_size1key+item_size1val;
21133 unsigned int count0=0;
21134 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21135 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21136 unsigned int pad_count0=0;
21137 for(;it0!=val0.end();++it0){
21138 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21139 unsigned int pad_count1val=0;
21140 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21141 for(;it1val!=it0->second.end();++it1val){
21142 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21143 unsigned int pad_count2valelem=0;
21144 std::pair<std::string, std::string> child3valelemsecond;
21145 unsigned int pad_count3valelemsecond=0;
21146 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21147 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21148 child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
21149 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21150 child1val.push_back(child2valelem);
21151 ++pad_count1val;
21152
21153 }
21154 child1val.resize(length1val);
21155 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21156 fixed_val0[it0->first] = child1val;
21157 ++pad_count0;
21158
21159 }
21160 hasher_.Clear();
21161 hasher_.Update(fixed_val0);
21162 Digest key0 = hasher_.digest();
21163 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
21164 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
21165 if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
21166 hvl_t buf0 = VLValToBuf(fixed_val0);
21167 AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
21168 InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
21169 }
21170 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21171}
21172template<>
21173void 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) {
21174 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>>>>>();
21175 size_t item_size0=(CYCLUS_SHA1_SIZE);
21176 size_t item_size1key=CYCLUS_SHA1_SIZE;
21177 size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
21178 size_t length1val=shape[2];
21179 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
21180 size_t item_size3valelemfirst=sizeof(int);
21181 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
21182 size_t item_size4valelemsecondfirst=shape[6];
21183 size_t valuelen4valelemsecondfirst;
21184 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21185 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21186 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21187 size_t total_item_size1val=item_size2valelem;
21188 size_t total_item_size0=item_size1key+item_size1val;
21189 unsigned int count0=0;
21190 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21191 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21192 unsigned int pad_count0=0;
21193 for(;it0!=val0.end();++it0){
21194 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21195 unsigned int pad_count1val=0;
21196 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21197 for(;it1val!=it0->second.end();++it1val){
21198 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21199 unsigned int pad_count2valelem=0;
21200 std::pair<std::string, std::string> child3valelemsecond;
21201 unsigned int pad_count3valelemsecond=0;
21202 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21203 child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
21204 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21205 child1val.push_back(child2valelem);
21206 ++pad_count1val;
21207
21208 }
21209 child1val.resize(length1val);
21210 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21211 fixed_val0[it0->first] = child1val;
21212 ++pad_count0;
21213
21214 }
21215 hasher_.Clear();
21216 hasher_.Update(fixed_val0);
21217 Digest key0 = hasher_.digest();
21218 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
21219 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
21220 if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
21221 hvl_t buf0 = VLValToBuf(fixed_val0);
21222 AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
21223 InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
21224 }
21225 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21226}
21227template<>
21228void 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) {
21229 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>>>>>();
21230 size_t item_size0=(CYCLUS_SHA1_SIZE);
21231 size_t item_size1key=CYCLUS_SHA1_SIZE;
21232 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
21233 size_t length1val=shape[2];
21234 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
21235 size_t item_size3valelemfirst=sizeof(int);
21236 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
21237 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21238 size_t item_size4valelemsecondsecond=shape[7];
21239 size_t valuelen4valelemsecondsecond;
21240 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21241 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21242 size_t total_item_size1val=item_size2valelem;
21243 size_t total_item_size0=item_size1key+item_size1val;
21244 unsigned int count0=0;
21245 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21246 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21247 unsigned int pad_count0=0;
21248 for(;it0!=val0.end();++it0){
21249 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21250 unsigned int pad_count1val=0;
21251 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21252 for(;it1val!=it0->second.end();++it1val){
21253 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21254 unsigned int pad_count2valelem=0;
21255 std::pair<std::string, std::string> child3valelemsecond;
21256 unsigned int pad_count3valelemsecond=0;
21257 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21258 child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
21259 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21260 child1val.push_back(child2valelem);
21261 ++pad_count1val;
21262
21263 }
21264 child1val.resize(length1val);
21265 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21266 fixed_val0[it0->first] = child1val;
21267 ++pad_count0;
21268
21269 }
21270 hasher_.Clear();
21271 hasher_.Update(fixed_val0);
21272 Digest key0 = hasher_.digest();
21273 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
21274 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
21275 if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
21276 hvl_t buf0 = VLValToBuf(fixed_val0);
21277 AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
21278 InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
21279 }
21280 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21281}
21282template<>
21283void 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) {
21284 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>>>>>();
21285 size_t item_size0=(CYCLUS_SHA1_SIZE);
21286 size_t item_size1key=CYCLUS_SHA1_SIZE;
21287 size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
21288 size_t length1val=shape[2];
21289 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
21290 size_t item_size3valelemfirst=sizeof(int);
21291 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
21292 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21293 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21294 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21295 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21296 size_t total_item_size1val=item_size2valelem;
21297 size_t total_item_size0=item_size1key+item_size1val;
21298 unsigned int count0=0;
21299 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21300 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21301 unsigned int pad_count0=0;
21302 for(;it0!=val0.end();++it0){
21303 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21304 unsigned int pad_count1val=0;
21305 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21306 for(;it1val!=it0->second.end();++it1val){
21307 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21308 unsigned int pad_count2valelem=0;
21309 std::pair<std::string, std::string> child3valelemsecond;
21310 unsigned int pad_count3valelemsecond=0;
21311 child3valelemsecond = std::make_pair((*it1val).second.first,(*it1val).second.second);
21312 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21313 child1val.push_back(child2valelem);
21314 ++pad_count1val;
21315
21316 }
21317 child1val.resize(length1val);
21318 memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21319 fixed_val0[it0->first] = child1val;
21320 ++pad_count0;
21321
21322 }
21323 hasher_.Clear();
21324 hasher_.Update(fixed_val0);
21325 Digest key0 = hasher_.digest();
21326 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
21327 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
21328 if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
21329 hvl_t buf0 = VLValToBuf(fixed_val0);
21330 AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0);
21331 InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
21332 }
21333 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21334}
21335template<>
21336void 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) {
21337 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>>>>>();
21338 size_t item_size0=(CYCLUS_SHA1_SIZE);
21339 size_t item_size1key=CYCLUS_SHA1_SIZE;
21340 size_t item_size1val=(CYCLUS_SHA1_SIZE);
21341 size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
21342 size_t item_size3valelemfirst=sizeof(int);
21343 size_t item_size3valelemsecond=((shape[6]+shape[7]));
21344 size_t item_size4valelemsecondfirst=shape[6];
21345 size_t valuelen4valelemsecondfirst;
21346 size_t item_size4valelemsecondsecond=shape[7];
21347 size_t valuelen4valelemsecondsecond;
21348 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21349 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21350 size_t total_item_size1val=item_size2valelem;
21351 size_t total_item_size0=item_size1key+item_size1val;
21352 unsigned int count0=0;
21353 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21354 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21355 unsigned int pad_count0=0;
21356 for(;it0!=val0.end();++it0){
21357 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21358 unsigned int pad_count1val=0;
21359 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21360 for(;it1val!=it0->second.end();++it1val){
21361 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21362 unsigned int pad_count2valelem=0;
21363 std::pair<std::string, std::string> child3valelemsecond;
21364 unsigned int pad_count3valelemsecond=0;
21365 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21366 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21367 child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
21368 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21369 child1val.push_back(child2valelem);
21370 ++pad_count1val;
21371
21372 }
21373 fixed_val0[it0->first] = child1val;
21374 ++pad_count0;
21375
21376 }
21377 hasher_.Clear();
21378 hasher_.Update(fixed_val0);
21379 Digest key0 = hasher_.digest();
21380 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
21381 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
21382 if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
21383 hvl_t buf0 = VLValToBuf(fixed_val0);
21384 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
21385 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
21386 }
21387 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21388}
21389template<>
21390void 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) {
21391 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>>>>>();
21392 size_t item_size0=(CYCLUS_SHA1_SIZE);
21393 size_t item_size1key=CYCLUS_SHA1_SIZE;
21394 size_t item_size1val=(CYCLUS_SHA1_SIZE);
21395 size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
21396 size_t item_size3valelemfirst=sizeof(int);
21397 size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
21398 size_t item_size4valelemsecondfirst=shape[6];
21399 size_t valuelen4valelemsecondfirst;
21400 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21401 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21402 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21403 size_t total_item_size1val=item_size2valelem;
21404 size_t total_item_size0=item_size1key+item_size1val;
21405 unsigned int count0=0;
21406 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21407 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21408 unsigned int pad_count0=0;
21409 for(;it0!=val0.end();++it0){
21410 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21411 unsigned int pad_count1val=0;
21412 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21413 for(;it1val!=it0->second.end();++it1val){
21414 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21415 unsigned int pad_count2valelem=0;
21416 std::pair<std::string, std::string> child3valelemsecond;
21417 unsigned int pad_count3valelemsecond=0;
21418 std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21419 child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
21420 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21421 child1val.push_back(child2valelem);
21422 ++pad_count1val;
21423
21424 }
21425 fixed_val0[it0->first] = child1val;
21426 ++pad_count0;
21427
21428 }
21429 hasher_.Clear();
21430 hasher_.Update(fixed_val0);
21431 Digest key0 = hasher_.digest();
21432 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
21433 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
21434 if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
21435 hvl_t buf0 = VLValToBuf(fixed_val0);
21436 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
21437 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
21438 }
21439 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21440}
21441template<>
21442void 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) {
21443 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>>>>>();
21444 size_t item_size0=(CYCLUS_SHA1_SIZE);
21445 size_t item_size1key=CYCLUS_SHA1_SIZE;
21446 size_t item_size1val=(CYCLUS_SHA1_SIZE);
21447 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
21448 size_t item_size3valelemfirst=sizeof(int);
21449 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
21450 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21451 size_t item_size4valelemsecondsecond=shape[7];
21452 size_t valuelen4valelemsecondsecond;
21453 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21454 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21455 size_t total_item_size1val=item_size2valelem;
21456 size_t total_item_size0=item_size1key+item_size1val;
21457 unsigned int count0=0;
21458 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21459 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21460 unsigned int pad_count0=0;
21461 for(;it0!=val0.end();++it0){
21462 std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21463 unsigned int pad_count1val=0;
21464 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21465 for(;it1val!=it0->second.end();++it1val){
21466 std::pair<int, std::pair<std::string, std::string>> child2valelem;
21467 unsigned int pad_count2valelem=0;
21468 std::pair<std::string, std::string> child3valelemsecond;
21469 unsigned int pad_count3valelemsecond=0;
21470 std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21471 child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
21472 child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21473 child1val.push_back(child2valelem);
21474 ++pad_count1val;
21475
21476 }
21477 fixed_val0[it0->first] = child1val;
21478 ++pad_count0;
21479
21480 }
21481 hasher_.Clear();
21482 hasher_.Update(fixed_val0);
21483 Digest key0 = hasher_.digest();
21484 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
21485 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
21486 if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
21487 hvl_t buf0 = VLValToBuf(fixed_val0);
21488 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
21489 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
21490 }
21491 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21492}
21493template<>
21494void 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) {
21495 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>>>>>();
21496 size_t item_size0=(CYCLUS_SHA1_SIZE);
21497 size_t item_size1key=CYCLUS_SHA1_SIZE;
21498 size_t item_size1val=(CYCLUS_SHA1_SIZE);
21499 size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
21500 size_t item_size3valelemfirst=sizeof(int);
21501 size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
21502 size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21503 size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21504 size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21505 size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21506 size_t total_item_size1val=item_size2valelem;
21507 size_t total_item_size0=item_size1key+item_size1val;
21508 hasher_.Clear();
21509 hasher_.Update(val0);
21510 Digest key0 = hasher_.digest();
21511 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
21512 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
21513 if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
21514 hvl_t buf0 = VLValToBuf(val0);
21515 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0);
21516 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
21517 }
21518 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21519}
21520template<>
21521void Hdf5Back::WriteToBuf<LIST_PAIR_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21522 std::list<std::pair<int, int>> val0=a->cast<std::list<std::pair<int, int>>>();
21523 size_t item_size0=((((sizeof(int)+sizeof(int))))*shape[0]);
21524 size_t length0=shape[0];
21525 size_t item_size1elem=((sizeof(int)+sizeof(int)));
21526 size_t item_size2elemfirst=sizeof(int);
21527 size_t item_size2elemsecond=sizeof(int);
21528 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
21529 size_t total_item_size0=item_size1elem;
21530 if(total_item_size0*val0.size()>column){
21531 std::list<std::pair<int, int>>::iterator eraseit=val0.begin();
21532 std::advance(eraseit, column/total_item_size0);
21533 val0.erase(eraseit,val0.end());
21534
21535 }
21536 unsigned int count0=0;
21537 std::list<std::pair<int, int>>::iterator it0=val0.begin();
21538 for(;it0!=val0.end();++it0){
21539 unsigned int count1elem=0;
21540 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
21541 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst, &(it0->second), item_size2elemsecond);
21542 ++count0;
21543
21544 }
21545 if(total_item_size0*length0<column){
21546 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21547
21548 }
21549}
21550template<>
21551void Hdf5Back::WriteToBuf<VL_LIST_PAIR_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21552 std::list<std::pair<int, int>> val0=a->cast<std::list<std::pair<int, int>>>();
21553 size_t item_size0=(CYCLUS_SHA1_SIZE);
21554 size_t item_size1elem=((sizeof(int)+sizeof(int)));
21555 size_t item_size2elemfirst=sizeof(int);
21556 size_t item_size2elemsecond=sizeof(int);
21557 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
21558 size_t total_item_size0=item_size1elem;
21559 hasher_.Clear();
21560 hasher_.Update(val0);
21561 Digest key0 = hasher_.digest();
21562 hid_t keysds0 = VLDataset(VL_LIST_PAIR_INT_INT, true);
21563 hid_t valsds0 = VLDataset(VL_LIST_PAIR_INT_INT, false);
21564 if (vlkeys_[VL_LIST_PAIR_INT_INT].count(key0) != 1) {
21565 hvl_t buf0 = VLValToBuf(val0);
21566 AppendVLKey(keysds0, VL_LIST_PAIR_INT_INT, key0);
21567 InsertVLVal(valsds0, VL_LIST_PAIR_INT_INT, key0, buf0);
21568 }
21569 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
21570}
21571template<>
21572void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21573 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>>>>();
21574 size_t item_size0=((shape[1]+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
21575 size_t length0=shape[0];
21576 size_t item_size1key=shape[1];
21577 size_t valuelen1key;
21578 size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
21579 size_t item_size2valfirst=shape[3];
21580 size_t valuelen2valfirst;
21581 size_t item_size2valsecond=((sizeof(double))*shape[4]);
21582 size_t length2valsecond=shape[4];
21583 size_t item_size3valsecondelem=sizeof(double);
21584 size_t total_item_size2valsecond=item_size3valsecondelem;
21585 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21586 size_t total_item_size0=item_size1key+item_size1val;
21587 if(total_item_size0*val0.size()>column){
21588 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21589 std::advance(eraseit, column/total_item_size0);
21590 val0.erase(eraseit,val0.end());
21591
21592 }
21593 unsigned int count0=0;
21594 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21595 for(;it0!=val0.end();++it0){
21596 valuelen1key=std::min(it0->first.size(), item_size1key);
21597 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21598 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21599 unsigned int count1val=0;
21600 valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21601 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21602 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21603 unsigned int count2valsecond=0;
21604 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21605 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21606 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21607 ++count2valsecond;
21608
21609 }
21610 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));
21611 ++count0;
21612
21613 }
21614 if(total_item_size0*length0<column){
21615 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21616
21617 }
21618}
21619template<>
21620void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21621 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>>>>();
21622 size_t item_size0=((shape[1]+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
21623 size_t length0=shape[0];
21624 size_t item_size1key=shape[1];
21625 size_t valuelen1key;
21626 size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
21627 size_t item_size2valfirst=shape[3];
21628 size_t valuelen2valfirst;
21629 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21630 size_t item_size3valsecondelem=sizeof(double);
21631 size_t total_item_size2valsecond=item_size3valsecondelem;
21632 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21633 size_t total_item_size0=item_size1key+item_size1val;
21634 if(total_item_size0*val0.size()>column){
21635 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21636 std::advance(eraseit, column/total_item_size0);
21637 val0.erase(eraseit,val0.end());
21638
21639 }
21640 unsigned int count0=0;
21641 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21642 for(;it0!=val0.end();++it0){
21643 valuelen1key=std::min(it0->first.size(), item_size1key);
21644 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21645 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21646 unsigned int count1val=0;
21647 valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21648 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21649 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21650 hasher_.Clear();
21651 hasher_.Update(it0->second.second);
21652 Digest key2valsecond = hasher_.digest();
21653 hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21654 hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21655 if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21656 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
21657 AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
21658 InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
21659 }
21660 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.data(), CYCLUS_SHA1_SIZE);
21661 ++count0;
21662
21663 }
21664 if(total_item_size0*length0<column){
21665 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21666
21667 }
21668}
21669template<>
21670void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21671 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>>>>();
21672 size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
21673 size_t length0=shape[0];
21674 size_t item_size1key=shape[1];
21675 size_t valuelen1key;
21676 size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
21677 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21678 size_t item_size2valsecond=((sizeof(double))*shape[4]);
21679 size_t length2valsecond=shape[4];
21680 size_t item_size3valsecondelem=sizeof(double);
21681 size_t total_item_size2valsecond=item_size3valsecondelem;
21682 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21683 size_t total_item_size0=item_size1key+item_size1val;
21684 if(total_item_size0*val0.size()>column){
21685 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21686 std::advance(eraseit, column/total_item_size0);
21687 val0.erase(eraseit,val0.end());
21688
21689 }
21690 unsigned int count0=0;
21691 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21692 for(;it0!=val0.end();++it0){
21693 valuelen1key=std::min(it0->first.size(), item_size1key);
21694 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21695 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21696 unsigned int count1val=0;
21697 hasher_.Clear();
21698 hasher_.Update(it0->second.first);
21699 Digest key2valfirst = hasher_.digest();
21700 hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21701 hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21702 if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21703 AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21704 InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21705 }
21706 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.data(), CYCLUS_SHA1_SIZE);
21707 unsigned int count2valsecond=0;
21708 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21709 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21710 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21711 ++count2valsecond;
21712
21713 }
21714 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));
21715 ++count0;
21716
21717 }
21718 if(total_item_size0*length0<column){
21719 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21720
21721 }
21722}
21723template<>
21724void 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) {
21725 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>>>>();
21726 size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
21727 size_t length0=shape[0];
21728 size_t item_size1key=shape[1];
21729 size_t valuelen1key;
21730 size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
21731 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21732 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21733 size_t item_size3valsecondelem=sizeof(double);
21734 size_t total_item_size2valsecond=item_size3valsecondelem;
21735 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21736 size_t total_item_size0=item_size1key+item_size1val;
21737 if(total_item_size0*val0.size()>column){
21738 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21739 std::advance(eraseit, column/total_item_size0);
21740 val0.erase(eraseit,val0.end());
21741
21742 }
21743 unsigned int count0=0;
21744 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21745 for(;it0!=val0.end();++it0){
21746 valuelen1key=std::min(it0->first.size(), item_size1key);
21747 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21748 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21749 unsigned int count1val=0;
21750 hasher_.Clear();
21751 hasher_.Update(it0->second.first);
21752 Digest key2valfirst = hasher_.digest();
21753 hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21754 hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21755 if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21756 AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21757 InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21758 }
21759 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.data(), CYCLUS_SHA1_SIZE);
21760 hasher_.Clear();
21761 hasher_.Update(it0->second.second);
21762 Digest key2valsecond = hasher_.digest();
21763 hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21764 hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21765 if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21766 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
21767 AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
21768 InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
21769 }
21770 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.data(), CYCLUS_SHA1_SIZE);
21771 ++count0;
21772
21773 }
21774 if(total_item_size0*length0<column){
21775 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21776
21777 }
21778}
21779template<>
21780void Hdf5Back::WriteToBuf<MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21781 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>>>>();
21782 size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
21783 size_t length0=shape[0];
21784 size_t item_size1key=CYCLUS_SHA1_SIZE;
21785 size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
21786 size_t item_size2valfirst=shape[3];
21787 size_t valuelen2valfirst;
21788 size_t item_size2valsecond=((sizeof(double))*shape[4]);
21789 size_t length2valsecond=shape[4];
21790 size_t item_size3valsecondelem=sizeof(double);
21791 size_t total_item_size2valsecond=item_size3valsecondelem;
21792 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21793 size_t total_item_size0=item_size1key+item_size1val;
21794 if(total_item_size0*val0.size()>column){
21795 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21796 std::advance(eraseit, column/total_item_size0);
21797 val0.erase(eraseit,val0.end());
21798
21799 }
21800 unsigned int count0=0;
21801 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21802 for(;it0!=val0.end();++it0){
21803 hasher_.Clear();
21804 hasher_.Update(it0->first);
21805 Digest key1key = hasher_.digest();
21806 hid_t keysds1key = VLDataset(VL_STRING, true);
21807 hid_t valsds1key = VLDataset(VL_STRING, false);
21808 if (vlkeys_[VL_STRING].count(key1key) != 1) {
21809 AppendVLKey(keysds1key, VL_STRING, key1key);
21810 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21811 }
21812 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
21813 unsigned int count1val=0;
21814 valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21815 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21816 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21817 unsigned int count2valsecond=0;
21818 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21819 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21820 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21821 ++count2valsecond;
21822
21823 }
21824 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));
21825 ++count0;
21826
21827 }
21828 if(total_item_size0*length0<column){
21829 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21830
21831 }
21832}
21833template<>
21834void 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) {
21835 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>>>>();
21836 size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
21837 size_t length0=shape[0];
21838 size_t item_size1key=CYCLUS_SHA1_SIZE;
21839 size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
21840 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21841 size_t item_size2valsecond=((sizeof(double))*shape[4]);
21842 size_t length2valsecond=shape[4];
21843 size_t item_size3valsecondelem=sizeof(double);
21844 size_t total_item_size2valsecond=item_size3valsecondelem;
21845 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21846 size_t total_item_size0=item_size1key+item_size1val;
21847 if(total_item_size0*val0.size()>column){
21848 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21849 std::advance(eraseit, column/total_item_size0);
21850 val0.erase(eraseit,val0.end());
21851
21852 }
21853 unsigned int count0=0;
21854 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21855 for(;it0!=val0.end();++it0){
21856 hasher_.Clear();
21857 hasher_.Update(it0->first);
21858 Digest key1key = hasher_.digest();
21859 hid_t keysds1key = VLDataset(VL_STRING, true);
21860 hid_t valsds1key = VLDataset(VL_STRING, false);
21861 if (vlkeys_[VL_STRING].count(key1key) != 1) {
21862 AppendVLKey(keysds1key, VL_STRING, key1key);
21863 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21864 }
21865 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
21866 unsigned int count1val=0;
21867 hasher_.Clear();
21868 hasher_.Update(it0->second.first);
21869 Digest key2valfirst = hasher_.digest();
21870 hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21871 hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21872 if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21873 AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21874 InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21875 }
21876 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.data(), CYCLUS_SHA1_SIZE);
21877 unsigned int count2valsecond=0;
21878 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21879 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21880 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21881 ++count2valsecond;
21882
21883 }
21884 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));
21885 ++count0;
21886
21887 }
21888 if(total_item_size0*length0<column){
21889 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21890
21891 }
21892}
21893template<>
21894void 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) {
21895 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>>>>();
21896 size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
21897 size_t length0=shape[0];
21898 size_t item_size1key=CYCLUS_SHA1_SIZE;
21899 size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
21900 size_t item_size2valfirst=shape[3];
21901 size_t valuelen2valfirst;
21902 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21903 size_t item_size3valsecondelem=sizeof(double);
21904 size_t total_item_size2valsecond=item_size3valsecondelem;
21905 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21906 size_t total_item_size0=item_size1key+item_size1val;
21907 if(total_item_size0*val0.size()>column){
21908 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21909 std::advance(eraseit, column/total_item_size0);
21910 val0.erase(eraseit,val0.end());
21911
21912 }
21913 unsigned int count0=0;
21914 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21915 for(;it0!=val0.end();++it0){
21916 hasher_.Clear();
21917 hasher_.Update(it0->first);
21918 Digest key1key = hasher_.digest();
21919 hid_t keysds1key = VLDataset(VL_STRING, true);
21920 hid_t valsds1key = VLDataset(VL_STRING, false);
21921 if (vlkeys_[VL_STRING].count(key1key) != 1) {
21922 AppendVLKey(keysds1key, VL_STRING, key1key);
21923 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21924 }
21925 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
21926 unsigned int count1val=0;
21927 valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21928 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21929 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21930 hasher_.Clear();
21931 hasher_.Update(it0->second.second);
21932 Digest key2valsecond = hasher_.digest();
21933 hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21934 hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21935 if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21936 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
21937 AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
21938 InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
21939 }
21940 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.data(), CYCLUS_SHA1_SIZE);
21941 ++count0;
21942
21943 }
21944 if(total_item_size0*length0<column){
21945 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21946
21947 }
21948}
21949template<>
21950void 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) {
21951 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>>>>();
21952 size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
21953 size_t length0=shape[0];
21954 size_t item_size1key=CYCLUS_SHA1_SIZE;
21955 size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
21956 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21957 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21958 size_t item_size3valsecondelem=sizeof(double);
21959 size_t total_item_size2valsecond=item_size3valsecondelem;
21960 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21961 size_t total_item_size0=item_size1key+item_size1val;
21962 if(total_item_size0*val0.size()>column){
21963 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21964 std::advance(eraseit, column/total_item_size0);
21965 val0.erase(eraseit,val0.end());
21966
21967 }
21968 unsigned int count0=0;
21969 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21970 for(;it0!=val0.end();++it0){
21971 hasher_.Clear();
21972 hasher_.Update(it0->first);
21973 Digest key1key = hasher_.digest();
21974 hid_t keysds1key = VLDataset(VL_STRING, true);
21975 hid_t valsds1key = VLDataset(VL_STRING, false);
21976 if (vlkeys_[VL_STRING].count(key1key) != 1) {
21977 AppendVLKey(keysds1key, VL_STRING, key1key);
21978 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21979 }
21980 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
21981 unsigned int count1val=0;
21982 hasher_.Clear();
21983 hasher_.Update(it0->second.first);
21984 Digest key2valfirst = hasher_.digest();
21985 hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21986 hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21987 if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21988 AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21989 InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21990 }
21991 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.data(), CYCLUS_SHA1_SIZE);
21992 hasher_.Clear();
21993 hasher_.Update(it0->second.second);
21994 Digest key2valsecond = hasher_.digest();
21995 hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21996 hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21997 if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21998 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
21999 AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
22000 InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
22001 }
22002 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.data(), CYCLUS_SHA1_SIZE);
22003 ++count0;
22004
22005 }
22006 if(total_item_size0*length0<column){
22007 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22008
22009 }
22010}
22011template<>
22012void Hdf5Back::WriteToBuf<VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22013 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>>>>();
22014 size_t item_size0=(CYCLUS_SHA1_SIZE);
22015 size_t item_size1key=shape[1];
22016 size_t valuelen1key;
22017 size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
22018 size_t item_size2valfirst=shape[3];
22019 size_t valuelen2valfirst;
22020 size_t item_size2valsecond=((sizeof(double))*shape[4]);
22021 size_t length2valsecond=shape[4];
22022 size_t item_size3valsecondelem=sizeof(double);
22023 size_t total_item_size2valsecond=item_size3valsecondelem;
22024 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22025 size_t total_item_size0=item_size1key+item_size1val;
22026 unsigned int count0=0;
22027 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22028 std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22029 unsigned int pad_count0=0;
22030 for(;it0!=val0.end();++it0){
22031 std::string child1key=std::string(it0->first,0,item_size1key);
22032 std::pair<std::string, std::vector<double>> child1val;
22033 unsigned int pad_count1val=0;
22034 std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22035 std::vector<double> child2valsecond;
22036 unsigned int pad_count2valsecond=0;
22037 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22038 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22039 child2valsecond.push_back((*it2valsecond));
22040 ++pad_count2valsecond;
22041
22042 }
22043 child2valsecond.resize(length2valsecond);
22044 memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22045 child1val = std::make_pair(child2valfirst,child2valsecond);
22046 fixed_val0[child1key] = child1val;
22047 ++pad_count0;
22048
22049 }
22050 hasher_.Clear();
22051 hasher_.Update(fixed_val0);
22052 Digest key0 = hasher_.digest();
22053 hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, true);
22054 hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, false);
22055 if (vlkeys_[VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22056 hvl_t buf0 = VLValToBuf(fixed_val0);
22057 AppendVLKey(keysds0, VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, key0);
22058 InsertVLVal(valsds0, VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, key0, buf0);
22059 }
22060 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22061}
22062template<>
22063void 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) {
22064 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>>>>();
22065 size_t item_size0=(CYCLUS_SHA1_SIZE);
22066 size_t item_size1key=CYCLUS_SHA1_SIZE;
22067 size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
22068 size_t item_size2valfirst=shape[3];
22069 size_t valuelen2valfirst;
22070 size_t item_size2valsecond=((sizeof(double))*shape[4]);
22071 size_t length2valsecond=shape[4];
22072 size_t item_size3valsecondelem=sizeof(double);
22073 size_t total_item_size2valsecond=item_size3valsecondelem;
22074 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22075 size_t total_item_size0=item_size1key+item_size1val;
22076 unsigned int count0=0;
22077 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22078 std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22079 unsigned int pad_count0=0;
22080 for(;it0!=val0.end();++it0){
22081 std::pair<std::string, std::vector<double>> child1val;
22082 unsigned int pad_count1val=0;
22083 std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22084 std::vector<double> child2valsecond;
22085 unsigned int pad_count2valsecond=0;
22086 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22087 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22088 child2valsecond.push_back((*it2valsecond));
22089 ++pad_count2valsecond;
22090
22091 }
22092 child2valsecond.resize(length2valsecond);
22093 memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22094 child1val = std::make_pair(child2valfirst,child2valsecond);
22095 fixed_val0[it0->first] = child1val;
22096 ++pad_count0;
22097
22098 }
22099 hasher_.Clear();
22100 hasher_.Update(fixed_val0);
22101 Digest key0 = hasher_.digest();
22102 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, true);
22103 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, false);
22104 if (vlkeys_[VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22105 hvl_t buf0 = VLValToBuf(fixed_val0);
22106 AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, key0);
22107 InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, key0, buf0);
22108 }
22109 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22110}
22111template<>
22112void 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) {
22113 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>>>>();
22114 size_t item_size0=(CYCLUS_SHA1_SIZE);
22115 size_t item_size1key=shape[1];
22116 size_t valuelen1key;
22117 size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
22118 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22119 size_t item_size2valsecond=((sizeof(double))*shape[4]);
22120 size_t length2valsecond=shape[4];
22121 size_t item_size3valsecondelem=sizeof(double);
22122 size_t total_item_size2valsecond=item_size3valsecondelem;
22123 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22124 size_t total_item_size0=item_size1key+item_size1val;
22125 unsigned int count0=0;
22126 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22127 std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22128 unsigned int pad_count0=0;
22129 for(;it0!=val0.end();++it0){
22130 std::string child1key=std::string(it0->first,0,item_size1key);
22131 std::pair<std::string, std::vector<double>> child1val;
22132 unsigned int pad_count1val=0;
22133 std::vector<double> child2valsecond;
22134 unsigned int pad_count2valsecond=0;
22135 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22136 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22137 child2valsecond.push_back((*it2valsecond));
22138 ++pad_count2valsecond;
22139
22140 }
22141 child2valsecond.resize(length2valsecond);
22142 memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22143 child1val = std::make_pair(it0->second.first,child2valsecond);
22144 fixed_val0[child1key] = child1val;
22145 ++pad_count0;
22146
22147 }
22148 hasher_.Clear();
22149 hasher_.Update(fixed_val0);
22150 Digest key0 = hasher_.digest();
22151 hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, true);
22152 hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, false);
22153 if (vlkeys_[VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22154 hvl_t buf0 = VLValToBuf(fixed_val0);
22155 AppendVLKey(keysds0, VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0);
22156 InsertVLVal(valsds0, VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0, buf0);
22157 }
22158 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22159}
22160template<>
22161void 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) {
22162 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>>>>();
22163 size_t item_size0=(CYCLUS_SHA1_SIZE);
22164 size_t item_size1key=shape[1];
22165 size_t valuelen1key;
22166 size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
22167 size_t item_size2valfirst=shape[3];
22168 size_t valuelen2valfirst;
22169 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22170 size_t item_size3valsecondelem=sizeof(double);
22171 size_t total_item_size2valsecond=item_size3valsecondelem;
22172 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22173 size_t total_item_size0=item_size1key+item_size1val;
22174 unsigned int count0=0;
22175 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22176 std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22177 unsigned int pad_count0=0;
22178 for(;it0!=val0.end();++it0){
22179 std::string child1key=std::string(it0->first,0,item_size1key);
22180 std::pair<std::string, std::vector<double>> child1val;
22181 unsigned int pad_count1val=0;
22182 std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22183 child1val = std::make_pair(child2valfirst,it0->second.second);
22184 fixed_val0[child1key] = child1val;
22185 ++pad_count0;
22186
22187 }
22188 hasher_.Clear();
22189 hasher_.Update(fixed_val0);
22190 Digest key0 = hasher_.digest();
22191 hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, true);
22192 hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, false);
22193 if (vlkeys_[VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22194 hvl_t buf0 = VLValToBuf(fixed_val0);
22195 AppendVLKey(keysds0, VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0);
22196 InsertVLVal(valsds0, VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22197 }
22198 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22199}
22200template<>
22201void 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) {
22202 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>>>>();
22203 size_t item_size0=(CYCLUS_SHA1_SIZE);
22204 size_t item_size1key=CYCLUS_SHA1_SIZE;
22205 size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
22206 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22207 size_t item_size2valsecond=((sizeof(double))*shape[4]);
22208 size_t length2valsecond=shape[4];
22209 size_t item_size3valsecondelem=sizeof(double);
22210 size_t total_item_size2valsecond=item_size3valsecondelem;
22211 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22212 size_t total_item_size0=item_size1key+item_size1val;
22213 unsigned int count0=0;
22214 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22215 std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22216 unsigned int pad_count0=0;
22217 for(;it0!=val0.end();++it0){
22218 std::pair<std::string, std::vector<double>> child1val;
22219 unsigned int pad_count1val=0;
22220 std::vector<double> child2valsecond;
22221 unsigned int pad_count2valsecond=0;
22222 std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22223 for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22224 child2valsecond.push_back((*it2valsecond));
22225 ++pad_count2valsecond;
22226
22227 }
22228 child2valsecond.resize(length2valsecond);
22229 memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22230 child1val = std::make_pair(it0->second.first,child2valsecond);
22231 fixed_val0[it0->first] = child1val;
22232 ++pad_count0;
22233
22234 }
22235 hasher_.Clear();
22236 hasher_.Update(fixed_val0);
22237 Digest key0 = hasher_.digest();
22238 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, true);
22239 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, false);
22240 if (vlkeys_[VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22241 hvl_t buf0 = VLValToBuf(fixed_val0);
22242 AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0);
22243 InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0, buf0);
22244 }
22245 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22246}
22247template<>
22248void 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) {
22249 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>>>>();
22250 size_t item_size0=(CYCLUS_SHA1_SIZE);
22251 size_t item_size1key=CYCLUS_SHA1_SIZE;
22252 size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
22253 size_t item_size2valfirst=shape[3];
22254 size_t valuelen2valfirst;
22255 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22256 size_t item_size3valsecondelem=sizeof(double);
22257 size_t total_item_size2valsecond=item_size3valsecondelem;
22258 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22259 size_t total_item_size0=item_size1key+item_size1val;
22260 unsigned int count0=0;
22261 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22262 std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22263 unsigned int pad_count0=0;
22264 for(;it0!=val0.end();++it0){
22265 std::pair<std::string, std::vector<double>> child1val;
22266 unsigned int pad_count1val=0;
22267 std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22268 child1val = std::make_pair(child2valfirst,it0->second.second);
22269 fixed_val0[it0->first] = child1val;
22270 ++pad_count0;
22271
22272 }
22273 hasher_.Clear();
22274 hasher_.Update(fixed_val0);
22275 Digest key0 = hasher_.digest();
22276 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, true);
22277 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, false);
22278 if (vlkeys_[VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22279 hvl_t buf0 = VLValToBuf(fixed_val0);
22280 AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0);
22281 InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22282 }
22283 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22284}
22285template<>
22286void 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) {
22287 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>>>>();
22288 size_t item_size0=(CYCLUS_SHA1_SIZE);
22289 size_t item_size1key=shape[1];
22290 size_t valuelen1key;
22291 size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
22292 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22293 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22294 size_t item_size3valsecondelem=sizeof(double);
22295 size_t total_item_size2valsecond=item_size3valsecondelem;
22296 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22297 size_t total_item_size0=item_size1key+item_size1val;
22298 unsigned int count0=0;
22299 std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22300 std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22301 unsigned int pad_count0=0;
22302 for(;it0!=val0.end();++it0){
22303 std::string child1key=std::string(it0->first,0,item_size1key);
22304 std::pair<std::string, std::vector<double>> child1val;
22305 unsigned int pad_count1val=0;
22306 child1val = std::make_pair(it0->second.first,it0->second.second);
22307 fixed_val0[child1key] = child1val;
22308 ++pad_count0;
22309
22310 }
22311 hasher_.Clear();
22312 hasher_.Update(fixed_val0);
22313 Digest key0 = hasher_.digest();
22314 hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, true);
22315 hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, false);
22316 if (vlkeys_[VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22317 hvl_t buf0 = VLValToBuf(fixed_val0);
22318 AppendVLKey(keysds0, VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0);
22319 InsertVLVal(valsds0, VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22320 }
22321 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22322}
22323template<>
22324void 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) {
22325 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>>>>();
22326 size_t item_size0=(CYCLUS_SHA1_SIZE);
22327 size_t item_size1key=CYCLUS_SHA1_SIZE;
22328 size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
22329 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22330 size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22331 size_t item_size3valsecondelem=sizeof(double);
22332 size_t total_item_size2valsecond=item_size3valsecondelem;
22333 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22334 size_t total_item_size0=item_size1key+item_size1val;
22335 hasher_.Clear();
22336 hasher_.Update(val0);
22337 Digest key0 = hasher_.digest();
22338 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, true);
22339 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, false);
22340 if (vlkeys_[VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22341 hvl_t buf0 = VLValToBuf(val0);
22342 AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0);
22343 InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22344 }
22345 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22346}
22347template<>
22348void Hdf5Back::WriteToBuf<MAP_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22349 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22350 size_t item_size0=((shape[1]+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
22351 size_t length0=shape[0];
22352 size_t item_size1key=shape[1];
22353 size_t valuelen1key;
22354 size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22355 size_t length1val=shape[2];
22356 size_t item_size2valkey=shape[3];
22357 size_t valuelen2valkey;
22358 size_t item_size2valval=sizeof(int);
22359 size_t total_item_size1val=item_size2valkey+item_size2valval;
22360 size_t total_item_size0=item_size1key+item_size1val;
22361 if(total_item_size0*val0.size()>column){
22362 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22363 std::advance(eraseit, column/total_item_size0);
22364 val0.erase(eraseit,val0.end());
22365
22366 }
22367 unsigned int count0=0;
22368 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22369 for(;it0!=val0.end();++it0){
22370 valuelen1key=std::min(it0->first.size(), item_size1key);
22371 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22372 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22373 unsigned int count1val=0;
22374 std::map<std::string, int>::iterator it1val=it0->second.begin();
22375 for(;it1val!=it0->second.end();++it1val){
22376 valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
22377 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
22378 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
22379 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22380 ++count1val;
22381
22382 }
22383 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22384 ++count0;
22385
22386 }
22387 if(total_item_size0*length0<column){
22388 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22389
22390 }
22391}
22392template<>
22393void Hdf5Back::WriteToBuf<MAP_STRING_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22394 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22395 size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
22396 size_t length0=shape[0];
22397 size_t item_size1key=shape[1];
22398 size_t valuelen1key;
22399 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22400 size_t length1val=shape[2];
22401 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22402 size_t item_size2valval=sizeof(int);
22403 size_t total_item_size1val=item_size2valkey+item_size2valval;
22404 size_t total_item_size0=item_size1key+item_size1val;
22405 if(total_item_size0*val0.size()>column){
22406 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22407 std::advance(eraseit, column/total_item_size0);
22408 val0.erase(eraseit,val0.end());
22409
22410 }
22411 unsigned int count0=0;
22412 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22413 for(;it0!=val0.end();++it0){
22414 valuelen1key=std::min(it0->first.size(), item_size1key);
22415 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22416 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22417 unsigned int count1val=0;
22418 std::map<std::string, int>::iterator it1val=it0->second.begin();
22419 for(;it1val!=it0->second.end();++it1val){
22420 hasher_.Clear();
22421 hasher_.Update(it1val->first);
22422 Digest key2valkey = hasher_.digest();
22423 hid_t keysds2valkey = VLDataset(VL_STRING, true);
22424 hid_t valsds2valkey = VLDataset(VL_STRING, false);
22425 if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
22426 AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
22427 InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
22428 }
22429 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.data(), CYCLUS_SHA1_SIZE);
22430 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22431 ++count1val;
22432
22433 }
22434 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22435 ++count0;
22436
22437 }
22438 if(total_item_size0*length0<column){
22439 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22440
22441 }
22442}
22443template<>
22444void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22445 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22446 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
22447 size_t length0=shape[0];
22448 size_t item_size1key=shape[1];
22449 size_t valuelen1key;
22450 size_t item_size1val=(CYCLUS_SHA1_SIZE);
22451 size_t item_size2valkey=shape[3];
22452 size_t valuelen2valkey;
22453 size_t item_size2valval=sizeof(int);
22454 size_t total_item_size1val=item_size2valkey+item_size2valval;
22455 size_t total_item_size0=item_size1key+item_size1val;
22456 if(total_item_size0*val0.size()>column){
22457 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22458 std::advance(eraseit, column/total_item_size0);
22459 val0.erase(eraseit,val0.end());
22460
22461 }
22462 unsigned int count0=0;
22463 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22464 for(;it0!=val0.end();++it0){
22465 valuelen1key=std::min(it0->first.size(), item_size1key);
22466 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22467 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22468 unsigned int count1val=0;
22469 std::map<std::string, int>::iterator it1val=it0->second.begin();
22470 std::map<std::string, int> fixed_val1val;
22471 unsigned int pad_count1val=0;
22472 for(;it1val!=it0->second.end();++it1val){
22473 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22474 fixed_val1val[child2valkey] = it1val->second;
22475 ++pad_count1val;
22476
22477 }
22478 hasher_.Clear();
22479 hasher_.Update(fixed_val1val);
22480 Digest key1val = hasher_.digest();
22481 hid_t keysds1val = VLDataset(VL_MAP_STRING_INT, true);
22482 hid_t valsds1val = VLDataset(VL_MAP_STRING_INT, false);
22483 if (vlkeys_[VL_MAP_STRING_INT].count(key1val) != 1) {
22484 hvl_t buf1val = VLValToBuf(fixed_val1val);
22485 AppendVLKey(keysds1val, VL_MAP_STRING_INT, key1val);
22486 InsertVLVal(valsds1val, VL_MAP_STRING_INT, key1val, buf1val);
22487 }
22488 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
22489 ++count0;
22490
22491 }
22492 if(total_item_size0*length0<column){
22493 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22494
22495 }
22496}
22497template<>
22498void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22499 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22500 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
22501 size_t length0=shape[0];
22502 size_t item_size1key=shape[1];
22503 size_t valuelen1key;
22504 size_t item_size1val=(CYCLUS_SHA1_SIZE);
22505 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22506 size_t item_size2valval=sizeof(int);
22507 size_t total_item_size1val=item_size2valkey+item_size2valval;
22508 size_t total_item_size0=item_size1key+item_size1val;
22509 if(total_item_size0*val0.size()>column){
22510 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22511 std::advance(eraseit, column/total_item_size0);
22512 val0.erase(eraseit,val0.end());
22513
22514 }
22515 unsigned int count0=0;
22516 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22517 for(;it0!=val0.end();++it0){
22518 valuelen1key=std::min(it0->first.size(), item_size1key);
22519 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22520 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22521 hasher_.Clear();
22522 hasher_.Update(it0->second);
22523 Digest key1val = hasher_.digest();
22524 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_INT, true);
22525 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_INT, false);
22526 if (vlkeys_[VL_MAP_VL_STRING_INT].count(key1val) != 1) {
22527 hvl_t buf1val = VLValToBuf(it0->second);
22528 AppendVLKey(keysds1val, VL_MAP_VL_STRING_INT, key1val);
22529 InsertVLVal(valsds1val, VL_MAP_VL_STRING_INT, key1val, buf1val);
22530 }
22531 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
22532 ++count0;
22533
22534 }
22535 if(total_item_size0*length0<column){
22536 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22537
22538 }
22539}
22540template<>
22541void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22542 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22543 size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
22544 size_t length0=shape[0];
22545 size_t item_size1key=CYCLUS_SHA1_SIZE;
22546 size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22547 size_t length1val=shape[2];
22548 size_t item_size2valkey=shape[3];
22549 size_t valuelen2valkey;
22550 size_t item_size2valval=sizeof(int);
22551 size_t total_item_size1val=item_size2valkey+item_size2valval;
22552 size_t total_item_size0=item_size1key+item_size1val;
22553 if(total_item_size0*val0.size()>column){
22554 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22555 std::advance(eraseit, column/total_item_size0);
22556 val0.erase(eraseit,val0.end());
22557
22558 }
22559 unsigned int count0=0;
22560 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22561 for(;it0!=val0.end();++it0){
22562 hasher_.Clear();
22563 hasher_.Update(it0->first);
22564 Digest key1key = hasher_.digest();
22565 hid_t keysds1key = VLDataset(VL_STRING, true);
22566 hid_t valsds1key = VLDataset(VL_STRING, false);
22567 if (vlkeys_[VL_STRING].count(key1key) != 1) {
22568 AppendVLKey(keysds1key, VL_STRING, key1key);
22569 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22570 }
22571 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
22572 unsigned int count1val=0;
22573 std::map<std::string, int>::iterator it1val=it0->second.begin();
22574 for(;it1val!=it0->second.end();++it1val){
22575 valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
22576 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
22577 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
22578 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22579 ++count1val;
22580
22581 }
22582 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22583 ++count0;
22584
22585 }
22586 if(total_item_size0*length0<column){
22587 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22588
22589 }
22590}
22591template<>
22592void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22593 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22594 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
22595 size_t length0=shape[0];
22596 size_t item_size1key=CYCLUS_SHA1_SIZE;
22597 size_t item_size1val=(CYCLUS_SHA1_SIZE);
22598 size_t item_size2valkey=shape[3];
22599 size_t valuelen2valkey;
22600 size_t item_size2valval=sizeof(int);
22601 size_t total_item_size1val=item_size2valkey+item_size2valval;
22602 size_t total_item_size0=item_size1key+item_size1val;
22603 if(total_item_size0*val0.size()>column){
22604 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22605 std::advance(eraseit, column/total_item_size0);
22606 val0.erase(eraseit,val0.end());
22607
22608 }
22609 unsigned int count0=0;
22610 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22611 for(;it0!=val0.end();++it0){
22612 hasher_.Clear();
22613 hasher_.Update(it0->first);
22614 Digest key1key = hasher_.digest();
22615 hid_t keysds1key = VLDataset(VL_STRING, true);
22616 hid_t valsds1key = VLDataset(VL_STRING, false);
22617 if (vlkeys_[VL_STRING].count(key1key) != 1) {
22618 AppendVLKey(keysds1key, VL_STRING, key1key);
22619 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22620 }
22621 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
22622 unsigned int count1val=0;
22623 std::map<std::string, int>::iterator it1val=it0->second.begin();
22624 std::map<std::string, int> fixed_val1val;
22625 unsigned int pad_count1val=0;
22626 for(;it1val!=it0->second.end();++it1val){
22627 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22628 fixed_val1val[child2valkey] = it1val->second;
22629 ++pad_count1val;
22630
22631 }
22632 hasher_.Clear();
22633 hasher_.Update(fixed_val1val);
22634 Digest key1val = hasher_.digest();
22635 hid_t keysds1val = VLDataset(VL_MAP_STRING_INT, true);
22636 hid_t valsds1val = VLDataset(VL_MAP_STRING_INT, false);
22637 if (vlkeys_[VL_MAP_STRING_INT].count(key1val) != 1) {
22638 hvl_t buf1val = VLValToBuf(fixed_val1val);
22639 AppendVLKey(keysds1val, VL_MAP_STRING_INT, key1val);
22640 InsertVLVal(valsds1val, VL_MAP_STRING_INT, key1val, buf1val);
22641 }
22642 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
22643 ++count0;
22644
22645 }
22646 if(total_item_size0*length0<column){
22647 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22648
22649 }
22650}
22651template<>
22652void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22653 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22654 size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
22655 size_t length0=shape[0];
22656 size_t item_size1key=CYCLUS_SHA1_SIZE;
22657 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22658 size_t length1val=shape[2];
22659 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22660 size_t item_size2valval=sizeof(int);
22661 size_t total_item_size1val=item_size2valkey+item_size2valval;
22662 size_t total_item_size0=item_size1key+item_size1val;
22663 if(total_item_size0*val0.size()>column){
22664 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22665 std::advance(eraseit, column/total_item_size0);
22666 val0.erase(eraseit,val0.end());
22667
22668 }
22669 unsigned int count0=0;
22670 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22671 for(;it0!=val0.end();++it0){
22672 hasher_.Clear();
22673 hasher_.Update(it0->first);
22674 Digest key1key = hasher_.digest();
22675 hid_t keysds1key = VLDataset(VL_STRING, true);
22676 hid_t valsds1key = VLDataset(VL_STRING, false);
22677 if (vlkeys_[VL_STRING].count(key1key) != 1) {
22678 AppendVLKey(keysds1key, VL_STRING, key1key);
22679 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22680 }
22681 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
22682 unsigned int count1val=0;
22683 std::map<std::string, int>::iterator it1val=it0->second.begin();
22684 for(;it1val!=it0->second.end();++it1val){
22685 hasher_.Clear();
22686 hasher_.Update(it1val->first);
22687 Digest key2valkey = hasher_.digest();
22688 hid_t keysds2valkey = VLDataset(VL_STRING, true);
22689 hid_t valsds2valkey = VLDataset(VL_STRING, false);
22690 if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
22691 AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
22692 InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
22693 }
22694 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.data(), CYCLUS_SHA1_SIZE);
22695 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22696 ++count1val;
22697
22698 }
22699 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22700 ++count0;
22701
22702 }
22703 if(total_item_size0*length0<column){
22704 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22705
22706 }
22707}
22708template<>
22709void 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) {
22710 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22711 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
22712 size_t length0=shape[0];
22713 size_t item_size1key=CYCLUS_SHA1_SIZE;
22714 size_t item_size1val=(CYCLUS_SHA1_SIZE);
22715 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22716 size_t item_size2valval=sizeof(int);
22717 size_t total_item_size1val=item_size2valkey+item_size2valval;
22718 size_t total_item_size0=item_size1key+item_size1val;
22719 if(total_item_size0*val0.size()>column){
22720 std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22721 std::advance(eraseit, column/total_item_size0);
22722 val0.erase(eraseit,val0.end());
22723
22724 }
22725 unsigned int count0=0;
22726 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22727 for(;it0!=val0.end();++it0){
22728 hasher_.Clear();
22729 hasher_.Update(it0->first);
22730 Digest key1key = hasher_.digest();
22731 hid_t keysds1key = VLDataset(VL_STRING, true);
22732 hid_t valsds1key = VLDataset(VL_STRING, false);
22733 if (vlkeys_[VL_STRING].count(key1key) != 1) {
22734 AppendVLKey(keysds1key, VL_STRING, key1key);
22735 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22736 }
22737 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
22738 hasher_.Clear();
22739 hasher_.Update(it0->second);
22740 Digest key1val = hasher_.digest();
22741 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_INT, true);
22742 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_INT, false);
22743 if (vlkeys_[VL_MAP_VL_STRING_INT].count(key1val) != 1) {
22744 hvl_t buf1val = VLValToBuf(it0->second);
22745 AppendVLKey(keysds1val, VL_MAP_VL_STRING_INT, key1val);
22746 InsertVLVal(valsds1val, VL_MAP_VL_STRING_INT, key1val, buf1val);
22747 }
22748 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
22749 ++count0;
22750
22751 }
22752 if(total_item_size0*length0<column){
22753 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22754
22755 }
22756}
22757template<>
22758void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22759 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22760 size_t item_size0=(CYCLUS_SHA1_SIZE);
22761 size_t item_size1key=shape[1];
22762 size_t valuelen1key;
22763 size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22764 size_t length1val=shape[2];
22765 size_t item_size2valkey=shape[3];
22766 size_t valuelen2valkey;
22767 size_t item_size2valval=sizeof(int);
22768 size_t total_item_size1val=item_size2valkey+item_size2valval;
22769 size_t total_item_size0=item_size1key+item_size1val;
22770 unsigned int count0=0;
22771 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22772 std::map<std::string, std::map<std::string, int>> fixed_val0;
22773 unsigned int pad_count0=0;
22774 for(;it0!=val0.end();++it0){
22775 std::string child1key=std::string(it0->first,0,item_size1key);
22776 std::map<std::string, int> child1val;
22777 unsigned int pad_count1val=0;
22778 std::map<std::string, int>::iterator it1val=it0->second.begin();
22779 for(;it1val!=it0->second.end();++it1val){
22780 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22781 child1val[child2valkey] = it1val->second;
22782 ++pad_count1val;
22783
22784 }
22785 fixed_val0[child1key] = child1val;
22786 ++pad_count0;
22787
22788 }
22789 hasher_.Clear();
22790 hasher_.Update(fixed_val0);
22791 Digest key0 = hasher_.digest();
22792 hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_STRING_INT, true);
22793 hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_STRING_INT, false);
22794 if (vlkeys_[VL_MAP_STRING_MAP_STRING_INT].count(key0) != 1) {
22795 hvl_t buf0 = VLValToBuf(fixed_val0);
22796 AppendVLKey(keysds0, VL_MAP_STRING_MAP_STRING_INT, key0);
22797 InsertVLVal(valsds0, VL_MAP_STRING_MAP_STRING_INT, key0, buf0);
22798 }
22799 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22800}
22801template<>
22802void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22803 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22804 size_t item_size0=(CYCLUS_SHA1_SIZE);
22805 size_t item_size1key=CYCLUS_SHA1_SIZE;
22806 size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22807 size_t length1val=shape[2];
22808 size_t item_size2valkey=shape[3];
22809 size_t valuelen2valkey;
22810 size_t item_size2valval=sizeof(int);
22811 size_t total_item_size1val=item_size2valkey+item_size2valval;
22812 size_t total_item_size0=item_size1key+item_size1val;
22813 unsigned int count0=0;
22814 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22815 std::map<std::string, std::map<std::string, int>> fixed_val0;
22816 unsigned int pad_count0=0;
22817 for(;it0!=val0.end();++it0){
22818 std::map<std::string, int> child1val;
22819 unsigned int pad_count1val=0;
22820 std::map<std::string, int>::iterator it1val=it0->second.begin();
22821 for(;it1val!=it0->second.end();++it1val){
22822 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22823 child1val[child2valkey] = it1val->second;
22824 ++pad_count1val;
22825
22826 }
22827 fixed_val0[it0->first] = child1val;
22828 ++pad_count0;
22829
22830 }
22831 hasher_.Clear();
22832 hasher_.Update(fixed_val0);
22833 Digest key0 = hasher_.digest();
22834 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_INT, true);
22835 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_INT, false);
22836 if (vlkeys_[VL_MAP_VL_STRING_MAP_STRING_INT].count(key0) != 1) {
22837 hvl_t buf0 = VLValToBuf(fixed_val0);
22838 AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_STRING_INT, key0);
22839 InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_STRING_INT, key0, buf0);
22840 }
22841 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22842}
22843template<>
22844void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22845 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22846 size_t item_size0=(CYCLUS_SHA1_SIZE);
22847 size_t item_size1key=shape[1];
22848 size_t valuelen1key;
22849 size_t item_size1val=(CYCLUS_SHA1_SIZE);
22850 size_t item_size2valkey=shape[3];
22851 size_t valuelen2valkey;
22852 size_t item_size2valval=sizeof(int);
22853 size_t total_item_size1val=item_size2valkey+item_size2valval;
22854 size_t total_item_size0=item_size1key+item_size1val;
22855 unsigned int count0=0;
22856 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22857 std::map<std::string, std::map<std::string, int>> fixed_val0;
22858 unsigned int pad_count0=0;
22859 for(;it0!=val0.end();++it0){
22860 std::string child1key=std::string(it0->first,0,item_size1key);
22861 std::map<std::string, int> child1val;
22862 unsigned int pad_count1val=0;
22863 std::map<std::string, int>::iterator it1val=it0->second.begin();
22864 for(;it1val!=it0->second.end();++it1val){
22865 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22866 child1val[child2valkey] = it1val->second;
22867 ++pad_count1val;
22868
22869 }
22870 fixed_val0[child1key] = child1val;
22871 ++pad_count0;
22872
22873 }
22874 hasher_.Clear();
22875 hasher_.Update(fixed_val0);
22876 Digest key0 = hasher_.digest();
22877 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_INT, true);
22878 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_INT, false);
22879 if (vlkeys_[VL_MAP_STRING_VL_MAP_STRING_INT].count(key0) != 1) {
22880 hvl_t buf0 = VLValToBuf(fixed_val0);
22881 AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_STRING_INT, key0);
22882 InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_STRING_INT, key0, buf0);
22883 }
22884 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22885}
22886template<>
22887void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22888 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22889 size_t item_size0=(CYCLUS_SHA1_SIZE);
22890 size_t item_size1key=shape[1];
22891 size_t valuelen1key;
22892 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22893 size_t length1val=shape[2];
22894 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22895 size_t item_size2valval=sizeof(int);
22896 size_t total_item_size1val=item_size2valkey+item_size2valval;
22897 size_t total_item_size0=item_size1key+item_size1val;
22898 unsigned int count0=0;
22899 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22900 std::map<std::string, std::map<std::string, int>> fixed_val0;
22901 unsigned int pad_count0=0;
22902 for(;it0!=val0.end();++it0){
22903 std::string child1key=std::string(it0->first,0,item_size1key);
22904 std::map<std::string, int> child1val;
22905 unsigned int pad_count1val=0;
22906 std::map<std::string, int>::iterator it1val=it0->second.begin();
22907 for(;it1val!=it0->second.end();++it1val){
22908 child1val[it1val->first] = it1val->second;
22909 ++pad_count1val;
22910
22911 }
22912 fixed_val0[child1key] = child1val;
22913 ++pad_count0;
22914
22915 }
22916 hasher_.Clear();
22917 hasher_.Update(fixed_val0);
22918 Digest key0 = hasher_.digest();
22919 hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_INT, true);
22920 hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_INT, false);
22921 if (vlkeys_[VL_MAP_STRING_MAP_VL_STRING_INT].count(key0) != 1) {
22922 hvl_t buf0 = VLValToBuf(fixed_val0);
22923 AppendVLKey(keysds0, VL_MAP_STRING_MAP_VL_STRING_INT, key0);
22924 InsertVLVal(valsds0, VL_MAP_STRING_MAP_VL_STRING_INT, key0, buf0);
22925 }
22926 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22927}
22928template<>
22929void 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) {
22930 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22931 size_t item_size0=(CYCLUS_SHA1_SIZE);
22932 size_t item_size1key=shape[1];
22933 size_t valuelen1key;
22934 size_t item_size1val=(CYCLUS_SHA1_SIZE);
22935 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22936 size_t item_size2valval=sizeof(int);
22937 size_t total_item_size1val=item_size2valkey+item_size2valval;
22938 size_t total_item_size0=item_size1key+item_size1val;
22939 unsigned int count0=0;
22940 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22941 std::map<std::string, std::map<std::string, int>> fixed_val0;
22942 unsigned int pad_count0=0;
22943 for(;it0!=val0.end();++it0){
22944 std::string child1key=std::string(it0->first,0,item_size1key);
22945 fixed_val0[child1key] = it0->second;
22946 ++pad_count0;
22947
22948 }
22949 hasher_.Clear();
22950 hasher_.Update(fixed_val0);
22951 Digest key0 = hasher_.digest();
22952 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_INT, true);
22953 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_INT, false);
22954 if (vlkeys_[VL_MAP_STRING_VL_MAP_VL_STRING_INT].count(key0) != 1) {
22955 hvl_t buf0 = VLValToBuf(fixed_val0);
22956 AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_VL_STRING_INT, key0);
22957 InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_VL_STRING_INT, key0, buf0);
22958 }
22959 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
22960}
22961template<>
22962void 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) {
22963 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22964 size_t item_size0=(CYCLUS_SHA1_SIZE);
22965 size_t item_size1key=CYCLUS_SHA1_SIZE;
22966 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22967 size_t length1val=shape[2];
22968 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22969 size_t item_size2valval=sizeof(int);
22970 size_t total_item_size1val=item_size2valkey+item_size2valval;
22971 size_t total_item_size0=item_size1key+item_size1val;
22972 unsigned int count0=0;
22973 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22974 std::map<std::string, std::map<std::string, int>> fixed_val0;
22975 unsigned int pad_count0=0;
22976 for(;it0!=val0.end();++it0){
22977 std::map<std::string, int> child1val;
22978 unsigned int pad_count1val=0;
22979 std::map<std::string, int>::iterator it1val=it0->second.begin();
22980 for(;it1val!=it0->second.end();++it1val){
22981 child1val[it1val->first] = it1val->second;
22982 ++pad_count1val;
22983
22984 }
22985 fixed_val0[it0->first] = child1val;
22986 ++pad_count0;
22987
22988 }
22989 hasher_.Clear();
22990 hasher_.Update(fixed_val0);
22991 Digest key0 = hasher_.digest();
22992 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_INT, true);
22993 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_INT, false);
22994 if (vlkeys_[VL_MAP_VL_STRING_MAP_VL_STRING_INT].count(key0) != 1) {
22995 hvl_t buf0 = VLValToBuf(fixed_val0);
22996 AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_VL_STRING_INT, key0);
22997 InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_VL_STRING_INT, key0, buf0);
22998 }
22999 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23000}
23001template<>
23002void 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) {
23003 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
23004 size_t item_size0=(CYCLUS_SHA1_SIZE);
23005 size_t item_size1key=CYCLUS_SHA1_SIZE;
23006 size_t item_size1val=(CYCLUS_SHA1_SIZE);
23007 size_t item_size2valkey=shape[3];
23008 size_t valuelen2valkey;
23009 size_t item_size2valval=sizeof(int);
23010 size_t total_item_size1val=item_size2valkey+item_size2valval;
23011 size_t total_item_size0=item_size1key+item_size1val;
23012 unsigned int count0=0;
23013 std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
23014 std::map<std::string, std::map<std::string, int>> fixed_val0;
23015 unsigned int pad_count0=0;
23016 for(;it0!=val0.end();++it0){
23017 std::map<std::string, int> child1val;
23018 unsigned int pad_count1val=0;
23019 std::map<std::string, int>::iterator it1val=it0->second.begin();
23020 for(;it1val!=it0->second.end();++it1val){
23021 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
23022 child1val[child2valkey] = it1val->second;
23023 ++pad_count1val;
23024
23025 }
23026 fixed_val0[it0->first] = child1val;
23027 ++pad_count0;
23028
23029 }
23030 hasher_.Clear();
23031 hasher_.Update(fixed_val0);
23032 Digest key0 = hasher_.digest();
23033 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_INT, true);
23034 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_INT, false);
23035 if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_STRING_INT].count(key0) != 1) {
23036 hvl_t buf0 = VLValToBuf(fixed_val0);
23037 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_STRING_INT, key0);
23038 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_STRING_INT, key0, buf0);
23039 }
23040 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23041}
23042template<>
23043void 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) {
23044 std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
23045 size_t item_size0=(CYCLUS_SHA1_SIZE);
23046 size_t item_size1key=CYCLUS_SHA1_SIZE;
23047 size_t item_size1val=(CYCLUS_SHA1_SIZE);
23048 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
23049 size_t item_size2valval=sizeof(int);
23050 size_t total_item_size1val=item_size2valkey+item_size2valval;
23051 size_t total_item_size0=item_size1key+item_size1val;
23052 hasher_.Clear();
23053 hasher_.Update(val0);
23054 Digest key0 = hasher_.digest();
23055 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, true);
23056 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, false);
23057 if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT].count(key0) != 1) {
23058 hvl_t buf0 = VLValToBuf(val0);
23059 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, key0);
23060 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, key0, buf0);
23061 }
23062 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23063}
23064template<>
23065void 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) {
23066 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>>>>();
23067 size_t item_size0=((((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5]))))*shape[0]);
23068 size_t length0=shape[0];
23069 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5])));
23070 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23071 size_t item_size3elemfirstfirst=sizeof(double);
23072 size_t item_size3elemfirstsecond=sizeof(double);
23073 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23074 size_t item_size2elemsecond=((shape[6]+sizeof(double))*shape[5]);
23075 size_t length2elemsecond=shape[5];
23076 size_t item_size3elemsecondkey=shape[6];
23077 size_t valuelen3elemsecondkey;
23078 size_t item_size3elemsecondval=sizeof(double);
23079 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23080 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23081 size_t total_item_size0=item_size1elem;
23082 if(total_item_size0*val0.size()>column){
23083 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23084 std::advance(eraseit, column/total_item_size0);
23085 val0.erase(eraseit,val0.end());
23086
23087 }
23088 unsigned int count0=0;
23089 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23090 for(;it0!=val0.end();++it0){
23091 unsigned int count1elem=0;
23092 unsigned int count2elemfirst=0;
23093 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23094 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23095 unsigned int count2elemsecond=0;
23096 std::map<std::string, double>::iterator it2elemsecond=it0->second.begin();
23097 for(;it2elemsecond!=it0->second.end();++it2elemsecond){
23098 valuelen3elemsecondkey=std::min(it2elemsecond->first.size(), item_size3elemsecondkey);
23099 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, it2elemsecond->first.c_str(), valuelen3elemsecondkey);
23100 memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+valuelen3elemsecondkey, 0, item_size3elemsecondkey-valuelen3elemsecondkey);
23101 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondkey, &(it2elemsecond->second), item_size3elemsecondval);
23102 ++count2elemsecond;
23103
23104 }
23105 memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+total_item_size2elemsecond*count2elemsecond, 0, total_item_size2elemsecond*(length2elemsecond-count2elemsecond));
23106 ++count0;
23107
23108 }
23109 if(total_item_size0*length0<column){
23110 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23111
23112 }
23113}
23114template<>
23115void 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) {
23116 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>>>>();
23117 size_t item_size0=((((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]))))*shape[0]);
23118 size_t length0=shape[0];
23119 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5])));
23120 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23121 size_t item_size3elemfirstfirst=sizeof(double);
23122 size_t item_size3elemfirstsecond=sizeof(double);
23123 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23124 size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]);
23125 size_t length2elemsecond=shape[5];
23126 size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23127 size_t item_size3elemsecondval=sizeof(double);
23128 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23129 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23130 size_t total_item_size0=item_size1elem;
23131 if(total_item_size0*val0.size()>column){
23132 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23133 std::advance(eraseit, column/total_item_size0);
23134 val0.erase(eraseit,val0.end());
23135
23136 }
23137 unsigned int count0=0;
23138 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23139 for(;it0!=val0.end();++it0){
23140 unsigned int count1elem=0;
23141 unsigned int count2elemfirst=0;
23142 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23143 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23144 unsigned int count2elemsecond=0;
23145 std::map<std::string, double>::iterator it2elemsecond=it0->second.begin();
23146 for(;it2elemsecond!=it0->second.end();++it2elemsecond){
23147 hasher_.Clear();
23148 hasher_.Update(it2elemsecond->first);
23149 Digest key3elemsecondkey = hasher_.digest();
23150 hid_t keysds3elemsecondkey = VLDataset(VL_STRING, true);
23151 hid_t valsds3elemsecondkey = VLDataset(VL_STRING, false);
23152 if (vlkeys_[VL_STRING].count(key3elemsecondkey) != 1) {
23153 AppendVLKey(keysds3elemsecondkey, VL_STRING, key3elemsecondkey);
23154 InsertVLVal(valsds3elemsecondkey, VL_STRING, key3elemsecondkey, it2elemsecond->first);
23155 }
23156 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, key3elemsecondkey.data(), CYCLUS_SHA1_SIZE);
23157 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondkey, &(it2elemsecond->second), item_size3elemsecondval);
23158 ++count2elemsecond;
23159
23160 }
23161 memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+total_item_size2elemsecond*count2elemsecond, 0, total_item_size2elemsecond*(length2elemsecond-count2elemsecond));
23162 ++count0;
23163
23164 }
23165 if(total_item_size0*length0<column){
23166 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23167
23168 }
23169}
23170template<>
23171void 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) {
23172 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>>>>();
23173 size_t item_size0=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
23174 size_t length0=shape[0];
23175 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23176 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23177 size_t item_size3elemfirstfirst=sizeof(double);
23178 size_t item_size3elemfirstsecond=sizeof(double);
23179 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23180 size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23181 size_t item_size3elemsecondkey=shape[6];
23182 size_t valuelen3elemsecondkey;
23183 size_t item_size3elemsecondval=sizeof(double);
23184 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23185 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23186 size_t total_item_size0=item_size1elem;
23187 if(total_item_size0*val0.size()>column){
23188 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23189 std::advance(eraseit, column/total_item_size0);
23190 val0.erase(eraseit,val0.end());
23191
23192 }
23193 unsigned int count0=0;
23194 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23195 for(;it0!=val0.end();++it0){
23196 unsigned int count1elem=0;
23197 unsigned int count2elemfirst=0;
23198 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23199 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23200 unsigned int count2elemsecond=0;
23201 std::map<std::string, double>::iterator it2elemsecond=it0->second.begin();
23202 std::map<std::string, double> fixed_val2elemsecond;
23203 unsigned int pad_count2elemsecond=0;
23204 for(;it2elemsecond!=it0->second.end();++it2elemsecond){
23205 std::string child3elemsecondkey=std::string(it2elemsecond->first,0,item_size3elemsecondkey);
23206 fixed_val2elemsecond[child3elemsecondkey] = it2elemsecond->second;
23207 ++pad_count2elemsecond;
23208
23209 }
23210 hasher_.Clear();
23211 hasher_.Update(fixed_val2elemsecond);
23212 Digest key2elemsecond = hasher_.digest();
23213 hid_t keysds2elemsecond = VLDataset(VL_MAP_STRING_DOUBLE, true);
23214 hid_t valsds2elemsecond = VLDataset(VL_MAP_STRING_DOUBLE, false);
23215 if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key2elemsecond) != 1) {
23216 hvl_t buf2elemsecond = VLValToBuf(fixed_val2elemsecond);
23217 AppendVLKey(keysds2elemsecond, VL_MAP_STRING_DOUBLE, key2elemsecond);
23218 InsertVLVal(valsds2elemsecond, VL_MAP_STRING_DOUBLE, key2elemsecond, buf2elemsecond);
23219 }
23220 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst, key2elemsecond.data(), CYCLUS_SHA1_SIZE);
23221 ++count0;
23222
23223 }
23224 if(total_item_size0*length0<column){
23225 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23226
23227 }
23228}
23229template<>
23230void 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) {
23231 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>>>>();
23232 size_t item_size0=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
23233 size_t length0=shape[0];
23234 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23235 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23236 size_t item_size3elemfirstfirst=sizeof(double);
23237 size_t item_size3elemfirstsecond=sizeof(double);
23238 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23239 size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23240 size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23241 size_t item_size3elemsecondval=sizeof(double);
23242 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23243 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23244 size_t total_item_size0=item_size1elem;
23245 if(total_item_size0*val0.size()>column){
23246 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23247 std::advance(eraseit, column/total_item_size0);
23248 val0.erase(eraseit,val0.end());
23249
23250 }
23251 unsigned int count0=0;
23252 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23253 for(;it0!=val0.end();++it0){
23254 unsigned int count1elem=0;
23255 unsigned int count2elemfirst=0;
23256 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23257 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23258 hasher_.Clear();
23259 hasher_.Update(it0->second);
23260 Digest key2elemsecond = hasher_.digest();
23261 hid_t keysds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
23262 hid_t valsds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
23263 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key2elemsecond) != 1) {
23264 hvl_t buf2elemsecond = VLValToBuf(it0->second);
23265 AppendVLKey(keysds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond);
23266 InsertVLVal(valsds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond, buf2elemsecond);
23267 }
23268 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst, key2elemsecond.data(), CYCLUS_SHA1_SIZE);
23269 ++count0;
23270
23271 }
23272 if(total_item_size0*length0<column){
23273 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23274
23275 }
23276}
23277template<>
23278void 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) {
23279 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>>>>();
23280 size_t item_size0=(CYCLUS_SHA1_SIZE);
23281 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5])));
23282 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23283 size_t item_size3elemfirstfirst=sizeof(double);
23284 size_t item_size3elemfirstsecond=sizeof(double);
23285 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23286 size_t item_size2elemsecond=((shape[6]+sizeof(double))*shape[5]);
23287 size_t length2elemsecond=shape[5];
23288 size_t item_size3elemsecondkey=shape[6];
23289 size_t valuelen3elemsecondkey;
23290 size_t item_size3elemsecondval=sizeof(double);
23291 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23292 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23293 size_t total_item_size0=item_size1elem;
23294 unsigned int count0=0;
23295 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23296 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> fixed_val0;
23297 unsigned int pad_count0=0;
23298 for(;it0!=val0.end();++it0){
23299 std::pair<std::pair<double, double>, std::map<std::string, double>> child1elem;
23300 unsigned int pad_count1elem=0;
23301 std::pair<double, double> child2elemfirst;
23302 unsigned int pad_count2elemfirst=0;
23303 child2elemfirst = std::make_pair((*it0).first.first,(*it0).first.second);
23304 std::map<std::string, double> child2elemsecond;
23305 unsigned int pad_count2elemsecond=0;
23306 std::map<std::string, double>::iterator it2elemsecond=(*it0).second.begin();
23307 for(;it2elemsecond!=(*it0).second.end();++it2elemsecond){
23308 std::string child3elemsecondkey=std::string(it2elemsecond->first,0,item_size3elemsecondkey);
23309 child2elemsecond[child3elemsecondkey] = it2elemsecond->second;
23310 ++pad_count2elemsecond;
23311
23312 }
23313 child1elem = std::make_pair(child2elemfirst,child2elemsecond);
23314 fixed_val0.push_back(child1elem);
23315 ++pad_count0;
23316
23317 }
23318 hasher_.Clear();
23319 hasher_.Update(fixed_val0);
23320 Digest key0 = hasher_.digest();
23321 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, true);
23322 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, false);
23323 if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE].count(key0) != 1) {
23324 hvl_t buf0 = VLValToBuf(fixed_val0);
23325 AppendVLKey(keysds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, key0);
23326 InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, key0, buf0);
23327 }
23328 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23329}
23330template<>
23331void 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) {
23332 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>>>>();
23333 size_t item_size0=(CYCLUS_SHA1_SIZE);
23334 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5])));
23335 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23336 size_t item_size3elemfirstfirst=sizeof(double);
23337 size_t item_size3elemfirstsecond=sizeof(double);
23338 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23339 size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]);
23340 size_t length2elemsecond=shape[5];
23341 size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23342 size_t item_size3elemsecondval=sizeof(double);
23343 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23344 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23345 size_t total_item_size0=item_size1elem;
23346 unsigned int count0=0;
23347 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23348 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> fixed_val0;
23349 unsigned int pad_count0=0;
23350 for(;it0!=val0.end();++it0){
23351 std::pair<std::pair<double, double>, std::map<std::string, double>> child1elem;
23352 unsigned int pad_count1elem=0;
23353 std::pair<double, double> child2elemfirst;
23354 unsigned int pad_count2elemfirst=0;
23355 child2elemfirst = std::make_pair((*it0).first.first,(*it0).first.second);
23356 std::map<std::string, double> child2elemsecond;
23357 unsigned int pad_count2elemsecond=0;
23358 std::map<std::string, double>::iterator it2elemsecond=(*it0).second.begin();
23359 for(;it2elemsecond!=(*it0).second.end();++it2elemsecond){
23360 child2elemsecond[it2elemsecond->first] = it2elemsecond->second;
23361 ++pad_count2elemsecond;
23362
23363 }
23364 child1elem = std::make_pair(child2elemfirst,child2elemsecond);
23365 fixed_val0.push_back(child1elem);
23366 ++pad_count0;
23367
23368 }
23369 hasher_.Clear();
23370 hasher_.Update(fixed_val0);
23371 Digest key0 = hasher_.digest();
23372 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, true);
23373 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, false);
23374 if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
23375 hvl_t buf0 = VLValToBuf(fixed_val0);
23376 AppendVLKey(keysds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, key0);
23377 InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, key0, buf0);
23378 }
23379 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23380}
23381template<>
23382void 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) {
23383 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>>>>();
23384 size_t item_size0=(CYCLUS_SHA1_SIZE);
23385 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23386 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23387 size_t item_size3elemfirstfirst=sizeof(double);
23388 size_t item_size3elemfirstsecond=sizeof(double);
23389 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23390 size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23391 size_t item_size3elemsecondkey=shape[6];
23392 size_t valuelen3elemsecondkey;
23393 size_t item_size3elemsecondval=sizeof(double);
23394 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23395 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23396 size_t total_item_size0=item_size1elem;
23397 unsigned int count0=0;
23398 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23399 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> fixed_val0;
23400 unsigned int pad_count0=0;
23401 for(;it0!=val0.end();++it0){
23402 std::pair<std::pair<double, double>, std::map<std::string, double>> child1elem;
23403 unsigned int pad_count1elem=0;
23404 std::pair<double, double> child2elemfirst;
23405 unsigned int pad_count2elemfirst=0;
23406 child2elemfirst = std::make_pair((*it0).first.first,(*it0).first.second);
23407 std::map<std::string, double> child2elemsecond;
23408 unsigned int pad_count2elemsecond=0;
23409 std::map<std::string, double>::iterator it2elemsecond=(*it0).second.begin();
23410 for(;it2elemsecond!=(*it0).second.end();++it2elemsecond){
23411 std::string child3elemsecondkey=std::string(it2elemsecond->first,0,item_size3elemsecondkey);
23412 child2elemsecond[child3elemsecondkey] = it2elemsecond->second;
23413 ++pad_count2elemsecond;
23414
23415 }
23416 child1elem = std::make_pair(child2elemfirst,child2elemsecond);
23417 fixed_val0.push_back(child1elem);
23418 ++pad_count0;
23419
23420 }
23421 hasher_.Clear();
23422 hasher_.Update(fixed_val0);
23423 Digest key0 = hasher_.digest();
23424 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, true);
23425 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, false);
23426 if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
23427 hvl_t buf0 = VLValToBuf(fixed_val0);
23428 AppendVLKey(keysds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, key0);
23429 InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, key0, buf0);
23430 }
23431 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23432}
23433template<>
23434void 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) {
23435 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>>>>();
23436 size_t item_size0=(CYCLUS_SHA1_SIZE);
23437 size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23438 size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23439 size_t item_size3elemfirstfirst=sizeof(double);
23440 size_t item_size3elemfirstsecond=sizeof(double);
23441 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23442 size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23443 size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23444 size_t item_size3elemsecondval=sizeof(double);
23445 size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23446 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23447 size_t total_item_size0=item_size1elem;
23448 hasher_.Clear();
23449 hasher_.Update(val0);
23450 Digest key0 = hasher_.digest();
23451 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE, true);
23452 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE, false);
23453 if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
23454 hvl_t buf0 = VLValToBuf(val0);
23455 AppendVLKey(keysds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE, key0);
23456 InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
23457 }
23458 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23459}
23460template<>
23461void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23462 std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23463 size_t item_size0=((sizeof(int)+((shape[3]+shape[4]))));
23464 size_t item_size1first=sizeof(int);
23465 size_t item_size1second=((shape[3]+shape[4]));
23466 size_t item_size2secondfirst=shape[3];
23467 size_t valuelen2secondfirst;
23468 size_t item_size2secondsecond=shape[4];
23469 size_t valuelen2secondsecond;
23470 size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23471 size_t total_item_size0=item_size1first+item_size1second;
23472 unsigned int count0=0;
23473 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23474 unsigned int count1second=0;
23475 valuelen2secondfirst=std::min(val0.second.first.size(), item_size2secondfirst);
23476 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, val0.second.first.c_str(), valuelen2secondfirst);
23477 memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+valuelen2secondfirst, 0, item_size2secondfirst-valuelen2secondfirst);
23478 valuelen2secondsecond=std::min(val0.second.second.size(), item_size2secondsecond);
23479 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, val0.second.second.c_str(), valuelen2secondsecond);
23480 memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst+valuelen2secondsecond, 0, item_size2secondsecond-valuelen2secondsecond);
23481}
23482template<>
23483void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23484 std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23485 size_t item_size0=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[4]))));
23486 size_t item_size1first=sizeof(int);
23487 size_t item_size1second=((CYCLUS_SHA1_SIZE+shape[4]));
23488 size_t item_size2secondfirst=CYCLUS_SHA1_SIZE;
23489 size_t item_size2secondsecond=shape[4];
23490 size_t valuelen2secondsecond;
23491 size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23492 size_t total_item_size0=item_size1first+item_size1second;
23493 unsigned int count0=0;
23494 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23495 unsigned int count1second=0;
23496 hasher_.Clear();
23497 hasher_.Update(val0.second.first);
23498 Digest key2secondfirst = hasher_.digest();
23499 hid_t keysds2secondfirst = VLDataset(VL_STRING, true);
23500 hid_t valsds2secondfirst = VLDataset(VL_STRING, false);
23501 if (vlkeys_[VL_STRING].count(key2secondfirst) != 1) {
23502 AppendVLKey(keysds2secondfirst, VL_STRING, key2secondfirst);
23503 InsertVLVal(valsds2secondfirst, VL_STRING, key2secondfirst, val0.second.first);
23504 }
23505 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, key2secondfirst.data(), CYCLUS_SHA1_SIZE);
23506 valuelen2secondsecond=std::min(val0.second.second.size(), item_size2secondsecond);
23507 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, val0.second.second.c_str(), valuelen2secondsecond);
23508 memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst+valuelen2secondsecond, 0, item_size2secondsecond-valuelen2secondsecond);
23509}
23510template<>
23511void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23512 std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23513 size_t item_size0=((sizeof(int)+((shape[3]+CYCLUS_SHA1_SIZE))));
23514 size_t item_size1first=sizeof(int);
23515 size_t item_size1second=((shape[3]+CYCLUS_SHA1_SIZE));
23516 size_t item_size2secondfirst=shape[3];
23517 size_t valuelen2secondfirst;
23518 size_t item_size2secondsecond=CYCLUS_SHA1_SIZE;
23519 size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23520 size_t total_item_size0=item_size1first+item_size1second;
23521 unsigned int count0=0;
23522 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23523 unsigned int count1second=0;
23524 valuelen2secondfirst=std::min(val0.second.first.size(), item_size2secondfirst);
23525 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, val0.second.first.c_str(), valuelen2secondfirst);
23526 memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+valuelen2secondfirst, 0, item_size2secondfirst-valuelen2secondfirst);
23527 hasher_.Clear();
23528 hasher_.Update(val0.second.second);
23529 Digest key2secondsecond = hasher_.digest();
23530 hid_t keysds2secondsecond = VLDataset(VL_STRING, true);
23531 hid_t valsds2secondsecond = VLDataset(VL_STRING, false);
23532 if (vlkeys_[VL_STRING].count(key2secondsecond) != 1) {
23533 AppendVLKey(keysds2secondsecond, VL_STRING, key2secondsecond);
23534 InsertVLVal(valsds2secondsecond, VL_STRING, key2secondsecond, val0.second.second);
23535 }
23536 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, key2secondsecond.data(), CYCLUS_SHA1_SIZE);
23537}
23538template<>
23539void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23540 std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23541 size_t item_size0=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
23542 size_t item_size1first=sizeof(int);
23543 size_t item_size1second=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
23544 size_t item_size2secondfirst=CYCLUS_SHA1_SIZE;
23545 size_t item_size2secondsecond=CYCLUS_SHA1_SIZE;
23546 size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23547 size_t total_item_size0=item_size1first+item_size1second;
23548 unsigned int count0=0;
23549 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23550 unsigned int count1second=0;
23551 hasher_.Clear();
23552 hasher_.Update(val0.second.first);
23553 Digest key2secondfirst = hasher_.digest();
23554 hid_t keysds2secondfirst = VLDataset(VL_STRING, true);
23555 hid_t valsds2secondfirst = VLDataset(VL_STRING, false);
23556 if (vlkeys_[VL_STRING].count(key2secondfirst) != 1) {
23557 AppendVLKey(keysds2secondfirst, VL_STRING, key2secondfirst);
23558 InsertVLVal(valsds2secondfirst, VL_STRING, key2secondfirst, val0.second.first);
23559 }
23560 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, key2secondfirst.data(), CYCLUS_SHA1_SIZE);
23561 hasher_.Clear();
23562 hasher_.Update(val0.second.second);
23563 Digest key2secondsecond = hasher_.digest();
23564 hid_t keysds2secondsecond = VLDataset(VL_STRING, true);
23565 hid_t valsds2secondsecond = VLDataset(VL_STRING, false);
23566 if (vlkeys_[VL_STRING].count(key2secondsecond) != 1) {
23567 AppendVLKey(keysds2secondsecond, VL_STRING, key2secondsecond);
23568 InsertVLVal(valsds2secondsecond, VL_STRING, key2secondsecond, val0.second.second);
23569 }
23570 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, key2secondsecond.data(), CYCLUS_SHA1_SIZE);
23571}
23572template<>
23573void Hdf5Back::WriteToBuf<PAIR_DOUBLE_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23574 std::pair<double, double> val0=a->cast<std::pair<double, double>>();
23575 size_t item_size0=((sizeof(double)+sizeof(double)));
23576 size_t item_size1first=sizeof(double);
23577 size_t item_size1second=sizeof(double);
23578 size_t total_item_size0=item_size1first+item_size1second;
23579 unsigned int count0=0;
23580 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23581 memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
23582}
23583template<>
23584void Hdf5Back::WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23585 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>>>();
23586 size_t item_size0=((((sizeof(double)+sizeof(double)))+((shape[5]+sizeof(double))*shape[4])));
23587 size_t item_size1first=((sizeof(double)+sizeof(double)));
23588 size_t item_size2firstfirst=sizeof(double);
23589 size_t item_size2firstsecond=sizeof(double);
23590 size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23591 size_t item_size1second=((shape[5]+sizeof(double))*shape[4]);
23592 size_t length1second=shape[4];
23593 size_t item_size2secondkey=shape[5];
23594 size_t valuelen2secondkey;
23595 size_t item_size2secondval=sizeof(double);
23596 size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23597 size_t total_item_size0=item_size1first+item_size1second;
23598 unsigned int count0=0;
23599 unsigned int count1first=0;
23600 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23601 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23602 unsigned int count1second=0;
23603 std::map<std::string, double>::iterator it1second=val0.second.begin();
23604 for(;it1second!=val0.second.end();++it1second){
23605 valuelen2secondkey=std::min(it1second->first.size(), item_size2secondkey);
23606 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, it1second->first.c_str(), valuelen2secondkey);
23607 memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+valuelen2secondkey, 0, item_size2secondkey-valuelen2secondkey);
23608 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondkey, &(it1second->second), item_size2secondval);
23609 ++count1second;
23610
23611 }
23612 memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
23613}
23614template<>
23615void 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) {
23616 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>>>();
23617 size_t item_size0=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4])));
23618 size_t item_size1first=((sizeof(double)+sizeof(double)));
23619 size_t item_size2firstfirst=sizeof(double);
23620 size_t item_size2firstsecond=sizeof(double);
23621 size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23622 size_t item_size1second=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4]);
23623 size_t length1second=shape[4];
23624 size_t item_size2secondkey=CYCLUS_SHA1_SIZE;
23625 size_t item_size2secondval=sizeof(double);
23626 size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23627 size_t total_item_size0=item_size1first+item_size1second;
23628 unsigned int count0=0;
23629 unsigned int count1first=0;
23630 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23631 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23632 unsigned int count1second=0;
23633 std::map<std::string, double>::iterator it1second=val0.second.begin();
23634 for(;it1second!=val0.second.end();++it1second){
23635 hasher_.Clear();
23636 hasher_.Update(it1second->first);
23637 Digest key2secondkey = hasher_.digest();
23638 hid_t keysds2secondkey = VLDataset(VL_STRING, true);
23639 hid_t valsds2secondkey = VLDataset(VL_STRING, false);
23640 if (vlkeys_[VL_STRING].count(key2secondkey) != 1) {
23641 AppendVLKey(keysds2secondkey, VL_STRING, key2secondkey);
23642 InsertVLVal(valsds2secondkey, VL_STRING, key2secondkey, it1second->first);
23643 }
23644 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, key2secondkey.data(), CYCLUS_SHA1_SIZE);
23645 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondkey, &(it1second->second), item_size2secondval);
23646 ++count1second;
23647
23648 }
23649 memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
23650}
23651template<>
23652void 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) {
23653 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>>>();
23654 size_t item_size0=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23655 size_t item_size1first=((sizeof(double)+sizeof(double)));
23656 size_t item_size2firstfirst=sizeof(double);
23657 size_t item_size2firstsecond=sizeof(double);
23658 size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23659 size_t item_size1second=(CYCLUS_SHA1_SIZE);
23660 size_t item_size2secondkey=shape[5];
23661 size_t valuelen2secondkey;
23662 size_t item_size2secondval=sizeof(double);
23663 size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23664 size_t total_item_size0=item_size1first+item_size1second;
23665 unsigned int count0=0;
23666 unsigned int count1first=0;
23667 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23668 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23669 unsigned int count1second=0;
23670 std::map<std::string, double>::iterator it1second=val0.second.begin();
23671 std::map<std::string, double> fixed_val1second;
23672 unsigned int pad_count1second=0;
23673 for(;it1second!=val0.second.end();++it1second){
23674 std::string child2secondkey=std::string(it1second->first,0,item_size2secondkey);
23675 fixed_val1second[child2secondkey] = it1second->second;
23676 ++pad_count1second;
23677
23678 }
23679 hasher_.Clear();
23680 hasher_.Update(fixed_val1second);
23681 Digest key1second = hasher_.digest();
23682 hid_t keysds1second = VLDataset(VL_MAP_STRING_DOUBLE, true);
23683 hid_t valsds1second = VLDataset(VL_MAP_STRING_DOUBLE, false);
23684 if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1second) != 1) {
23685 hvl_t buf1second = VLValToBuf(fixed_val1second);
23686 AppendVLKey(keysds1second, VL_MAP_STRING_DOUBLE, key1second);
23687 InsertVLVal(valsds1second, VL_MAP_STRING_DOUBLE, key1second, buf1second);
23688 }
23689 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
23690}
23691template<>
23692void 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) {
23693 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>>>();
23694 size_t item_size0=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23695 size_t item_size1first=((sizeof(double)+sizeof(double)));
23696 size_t item_size2firstfirst=sizeof(double);
23697 size_t item_size2firstsecond=sizeof(double);
23698 size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23699 size_t item_size1second=(CYCLUS_SHA1_SIZE);
23700 size_t item_size2secondkey=CYCLUS_SHA1_SIZE;
23701 size_t item_size2secondval=sizeof(double);
23702 size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23703 size_t total_item_size0=item_size1first+item_size1second;
23704 unsigned int count0=0;
23705 unsigned int count1first=0;
23706 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23707 memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23708 hasher_.Clear();
23709 hasher_.Update(val0.second);
23710 Digest key1second = hasher_.digest();
23711 hid_t keysds1second = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
23712 hid_t valsds1second = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
23713 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1second) != 1) {
23714 hvl_t buf1second = VLValToBuf(val0.second);
23715 AppendVLKey(keysds1second, VL_MAP_VL_STRING_DOUBLE, key1second);
23716 InsertVLVal(valsds1second, VL_MAP_VL_STRING_DOUBLE, key1second, buf1second);
23717 }
23718 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
23719}
23720template<>
23721void Hdf5Back::WriteToBuf<PAIR_DOUBLE_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23722 std::pair<double, std::map<int, double>> val0=a->cast<std::pair<double, std::map<int, double>>>();
23723 size_t item_size0=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[2])));
23724 size_t item_size1first=sizeof(double);
23725 size_t item_size1second=((sizeof(int)+sizeof(double))*shape[2]);
23726 size_t length1second=shape[2];
23727 size_t item_size2secondkey=sizeof(int);
23728 size_t item_size2secondval=sizeof(double);
23729 size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23730 size_t total_item_size0=item_size1first+item_size1second;
23731 unsigned int count0=0;
23732 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23733 unsigned int count1second=0;
23734 std::map<int, double>::iterator it1second=val0.second.begin();
23735 for(;it1second!=val0.second.end();++it1second){
23736 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, &(it1second->first), item_size2secondkey);
23737 memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondkey, &(it1second->second), item_size2secondval);
23738 ++count1second;
23739
23740 }
23741 memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
23742}
23743template<>
23744void Hdf5Back::WriteToBuf<PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23745 std::pair<double, std::map<int, double>> val0=a->cast<std::pair<double, std::map<int, double>>>();
23746 size_t item_size0=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
23747 size_t item_size1first=sizeof(double);
23748 size_t item_size1second=(CYCLUS_SHA1_SIZE);
23749 size_t item_size2secondkey=sizeof(int);
23750 size_t item_size2secondval=sizeof(double);
23751 size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23752 size_t total_item_size0=item_size1first+item_size1second;
23753 unsigned int count0=0;
23754 memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23755 hasher_.Clear();
23756 hasher_.Update(val0.second);
23757 Digest key1second = hasher_.digest();
23758 hid_t keysds1second = VLDataset(VL_MAP_INT_DOUBLE, true);
23759 hid_t valsds1second = VLDataset(VL_MAP_INT_DOUBLE, false);
23760 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1second) != 1) {
23761 hvl_t buf1second = VLValToBuf(val0.second);
23762 AppendVLKey(keysds1second, VL_MAP_INT_DOUBLE, key1second);
23763 InsertVLVal(valsds1second, VL_MAP_INT_DOUBLE, key1second, buf1second);
23764 }
23765 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
23766}
23767template<>
23768void Hdf5Back::WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23769 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>>>>();
23770 size_t item_size0=((((sizeof(int)+((shape[4]+shape[5])))))*shape[0]);
23771 size_t length0=shape[0];
23772 size_t item_size1elem=((sizeof(int)+((shape[4]+shape[5]))));
23773 size_t item_size2elemfirst=sizeof(int);
23774 size_t item_size2elemsecond=((shape[4]+shape[5]));
23775 size_t item_size3elemsecondfirst=shape[4];
23776 size_t valuelen3elemsecondfirst;
23777 size_t item_size3elemsecondsecond=shape[5];
23778 size_t valuelen3elemsecondsecond;
23779 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23780 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23781 size_t total_item_size0=item_size1elem;
23782 if(total_item_size0*val0.size()>column){
23783 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23784 std::advance(eraseit, column/total_item_size0);
23785 val0.erase(eraseit,val0.end());
23786
23787 }
23788 unsigned int count0=0;
23789 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23790 for(;it0!=val0.end();++it0){
23791 unsigned int count1elem=0;
23792 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23793 unsigned int count2elemsecond=0;
23794 valuelen3elemsecondfirst=std::min(it0->second.first.size(), item_size3elemsecondfirst);
23795 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, it0->second.first.c_str(), valuelen3elemsecondfirst);
23796 memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+valuelen3elemsecondfirst, 0, item_size3elemsecondfirst-valuelen3elemsecondfirst);
23797 valuelen3elemsecondsecond=std::min(it0->second.second.size(), item_size3elemsecondsecond);
23798 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);
23799 memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst+valuelen3elemsecondsecond, 0, item_size3elemsecondsecond-valuelen3elemsecondsecond);
23800 ++count0;
23801
23802 }
23803 if(total_item_size0*length0<column){
23804 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23805
23806 }
23807}
23808template<>
23809void Hdf5Back::WriteToBuf<VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23810 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>>>>();
23811 size_t item_size0=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5])))))*shape[0]);
23812 size_t length0=shape[0];
23813 size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5]))));
23814 size_t item_size2elemfirst=sizeof(int);
23815 size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+shape[5]));
23816 size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
23817 size_t item_size3elemsecondsecond=shape[5];
23818 size_t valuelen3elemsecondsecond;
23819 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23820 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23821 size_t total_item_size0=item_size1elem;
23822 if(total_item_size0*val0.size()>column){
23823 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23824 std::advance(eraseit, column/total_item_size0);
23825 val0.erase(eraseit,val0.end());
23826
23827 }
23828 unsigned int count0=0;
23829 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23830 for(;it0!=val0.end();++it0){
23831 unsigned int count1elem=0;
23832 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23833 unsigned int count2elemsecond=0;
23834 hasher_.Clear();
23835 hasher_.Update(it0->second.first);
23836 Digest key3elemsecondfirst = hasher_.digest();
23837 hid_t keysds3elemsecondfirst = VLDataset(VL_STRING, true);
23838 hid_t valsds3elemsecondfirst = VLDataset(VL_STRING, false);
23839 if (vlkeys_[VL_STRING].count(key3elemsecondfirst) != 1) {
23840 AppendVLKey(keysds3elemsecondfirst, VL_STRING, key3elemsecondfirst);
23841 InsertVLVal(valsds3elemsecondfirst, VL_STRING, key3elemsecondfirst, it0->second.first);
23842 }
23843 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, key3elemsecondfirst.data(), CYCLUS_SHA1_SIZE);
23844 valuelen3elemsecondsecond=std::min(it0->second.second.size(), item_size3elemsecondsecond);
23845 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);
23846 memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst+valuelen3elemsecondsecond, 0, item_size3elemsecondsecond-valuelen3elemsecondsecond);
23847 ++count0;
23848
23849 }
23850 if(total_item_size0*length0<column){
23851 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23852
23853 }
23854}
23855template<>
23856void Hdf5Back::WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23857 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>>>>();
23858 size_t item_size0=((((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE)))))*shape[0]);
23859 size_t length0=shape[0];
23860 size_t item_size1elem=((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE))));
23861 size_t item_size2elemfirst=sizeof(int);
23862 size_t item_size2elemsecond=((shape[4]+CYCLUS_SHA1_SIZE));
23863 size_t item_size3elemsecondfirst=shape[4];
23864 size_t valuelen3elemsecondfirst;
23865 size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
23866 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23867 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23868 size_t total_item_size0=item_size1elem;
23869 if(total_item_size0*val0.size()>column){
23870 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23871 std::advance(eraseit, column/total_item_size0);
23872 val0.erase(eraseit,val0.end());
23873
23874 }
23875 unsigned int count0=0;
23876 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23877 for(;it0!=val0.end();++it0){
23878 unsigned int count1elem=0;
23879 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23880 unsigned int count2elemsecond=0;
23881 valuelen3elemsecondfirst=std::min(it0->second.first.size(), item_size3elemsecondfirst);
23882 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, it0->second.first.c_str(), valuelen3elemsecondfirst);
23883 memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+valuelen3elemsecondfirst, 0, item_size3elemsecondfirst-valuelen3elemsecondfirst);
23884 hasher_.Clear();
23885 hasher_.Update(it0->second.second);
23886 Digest key3elemsecondsecond = hasher_.digest();
23887 hid_t keysds3elemsecondsecond = VLDataset(VL_STRING, true);
23888 hid_t valsds3elemsecondsecond = VLDataset(VL_STRING, false);
23889 if (vlkeys_[VL_STRING].count(key3elemsecondsecond) != 1) {
23890 AppendVLKey(keysds3elemsecondsecond, VL_STRING, key3elemsecondsecond);
23891 InsertVLVal(valsds3elemsecondsecond, VL_STRING, key3elemsecondsecond, it0->second.second);
23892 }
23893 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst, key3elemsecondsecond.data(), CYCLUS_SHA1_SIZE);
23894 ++count0;
23895
23896 }
23897 if(total_item_size0*length0<column){
23898 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23899
23900 }
23901}
23902template<>
23903void 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) {
23904 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>>>>();
23905 size_t item_size0=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[0]);
23906 size_t length0=shape[0];
23907 size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
23908 size_t item_size2elemfirst=sizeof(int);
23909 size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
23910 size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
23911 size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
23912 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23913 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23914 size_t total_item_size0=item_size1elem;
23915 if(total_item_size0*val0.size()>column){
23916 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23917 std::advance(eraseit, column/total_item_size0);
23918 val0.erase(eraseit,val0.end());
23919
23920 }
23921 unsigned int count0=0;
23922 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23923 for(;it0!=val0.end();++it0){
23924 unsigned int count1elem=0;
23925 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23926 unsigned int count2elemsecond=0;
23927 hasher_.Clear();
23928 hasher_.Update(it0->second.first);
23929 Digest key3elemsecondfirst = hasher_.digest();
23930 hid_t keysds3elemsecondfirst = VLDataset(VL_STRING, true);
23931 hid_t valsds3elemsecondfirst = VLDataset(VL_STRING, false);
23932 if (vlkeys_[VL_STRING].count(key3elemsecondfirst) != 1) {
23933 AppendVLKey(keysds3elemsecondfirst, VL_STRING, key3elemsecondfirst);
23934 InsertVLVal(valsds3elemsecondfirst, VL_STRING, key3elemsecondfirst, it0->second.first);
23935 }
23936 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, key3elemsecondfirst.data(), CYCLUS_SHA1_SIZE);
23937 hasher_.Clear();
23938 hasher_.Update(it0->second.second);
23939 Digest key3elemsecondsecond = hasher_.digest();
23940 hid_t keysds3elemsecondsecond = VLDataset(VL_STRING, true);
23941 hid_t valsds3elemsecondsecond = VLDataset(VL_STRING, false);
23942 if (vlkeys_[VL_STRING].count(key3elemsecondsecond) != 1) {
23943 AppendVLKey(keysds3elemsecondsecond, VL_STRING, key3elemsecondsecond);
23944 InsertVLVal(valsds3elemsecondsecond, VL_STRING, key3elemsecondsecond, it0->second.second);
23945 }
23946 memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst, key3elemsecondsecond.data(), CYCLUS_SHA1_SIZE);
23947 ++count0;
23948
23949 }
23950 if(total_item_size0*length0<column){
23951 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23952
23953 }
23954}
23955template<>
23956void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23957 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>>>>();
23958 size_t item_size0=(CYCLUS_SHA1_SIZE);
23959 size_t item_size1elem=((sizeof(int)+((shape[4]+shape[5]))));
23960 size_t item_size2elemfirst=sizeof(int);
23961 size_t item_size2elemsecond=((shape[4]+shape[5]));
23962 size_t item_size3elemsecondfirst=shape[4];
23963 size_t valuelen3elemsecondfirst;
23964 size_t item_size3elemsecondsecond=shape[5];
23965 size_t valuelen3elemsecondsecond;
23966 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23967 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23968 size_t total_item_size0=item_size1elem;
23969 unsigned int count0=0;
23970 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23971 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val0;
23972 unsigned int pad_count0=0;
23973 for(;it0!=val0.end();++it0){
23974 std::pair<int, std::pair<std::string, std::string>> child1elem;
23975 unsigned int pad_count1elem=0;
23976 std::pair<std::string, std::string> child2elemsecond;
23977 unsigned int pad_count2elemsecond=0;
23978 std::string child3elemsecondfirst=std::string((*it0).second.first,0,item_size3elemsecondfirst);
23979 std::string child3elemsecondsecond=std::string((*it0).second.second,0,item_size3elemsecondsecond);
23980 child2elemsecond = std::make_pair(child3elemsecondfirst,child3elemsecondsecond);
23981 child1elem = std::make_pair((*it0).first,child2elemsecond);
23982 fixed_val0.push_back(child1elem);
23983 ++pad_count0;
23984
23985 }
23986 hasher_.Clear();
23987 hasher_.Update(fixed_val0);
23988 Digest key0 = hasher_.digest();
23989 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
23990 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
23991 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
23992 hvl_t buf0 = VLValToBuf(fixed_val0);
23993 AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
23994 InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
23995 }
23996 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
23997}
23998template<>
23999void 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) {
24000 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>>>>();
24001 size_t item_size0=(CYCLUS_SHA1_SIZE);
24002 size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5]))));
24003 size_t item_size2elemfirst=sizeof(int);
24004 size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+shape[5]));
24005 size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
24006 size_t item_size3elemsecondsecond=shape[5];
24007 size_t valuelen3elemsecondsecond;
24008 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
24009 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
24010 size_t total_item_size0=item_size1elem;
24011 unsigned int count0=0;
24012 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
24013 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val0;
24014 unsigned int pad_count0=0;
24015 for(;it0!=val0.end();++it0){
24016 std::pair<int, std::pair<std::string, std::string>> child1elem;
24017 unsigned int pad_count1elem=0;
24018 std::pair<std::string, std::string> child2elemsecond;
24019 unsigned int pad_count2elemsecond=0;
24020 std::string child3elemsecondsecond=std::string((*it0).second.second,0,item_size3elemsecondsecond);
24021 child2elemsecond = std::make_pair((*it0).second.first,child3elemsecondsecond);
24022 child1elem = std::make_pair((*it0).first,child2elemsecond);
24023 fixed_val0.push_back(child1elem);
24024 ++pad_count0;
24025
24026 }
24027 hasher_.Clear();
24028 hasher_.Update(fixed_val0);
24029 Digest key0 = hasher_.digest();
24030 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
24031 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
24032 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
24033 hvl_t buf0 = VLValToBuf(fixed_val0);
24034 AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
24035 InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
24036 }
24037 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24038}
24039template<>
24040void 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) {
24041 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>>>>();
24042 size_t item_size0=(CYCLUS_SHA1_SIZE);
24043 size_t item_size1elem=((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE))));
24044 size_t item_size2elemfirst=sizeof(int);
24045 size_t item_size2elemsecond=((shape[4]+CYCLUS_SHA1_SIZE));
24046 size_t item_size3elemsecondfirst=shape[4];
24047 size_t valuelen3elemsecondfirst;
24048 size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
24049 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
24050 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
24051 size_t total_item_size0=item_size1elem;
24052 unsigned int count0=0;
24053 std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
24054 std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val0;
24055 unsigned int pad_count0=0;
24056 for(;it0!=val0.end();++it0){
24057 std::pair<int, std::pair<std::string, std::string>> child1elem;
24058 unsigned int pad_count1elem=0;
24059 std::pair<std::string, std::string> child2elemsecond;
24060 unsigned int pad_count2elemsecond=0;
24061 std::string child3elemsecondfirst=std::string((*it0).second.first,0,item_size3elemsecondfirst);
24062 child2elemsecond = std::make_pair(child3elemsecondfirst,(*it0).second.second);
24063 child1elem = std::make_pair((*it0).first,child2elemsecond);
24064 fixed_val0.push_back(child1elem);
24065 ++pad_count0;
24066
24067 }
24068 hasher_.Clear();
24069 hasher_.Update(fixed_val0);
24070 Digest key0 = hasher_.digest();
24071 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
24072 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
24073 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
24074 hvl_t buf0 = VLValToBuf(fixed_val0);
24075 AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
24076 InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
24077 }
24078 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24079}
24080template<>
24081void 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) {
24082 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>>>>();
24083 size_t item_size0=(CYCLUS_SHA1_SIZE);
24084 size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
24085 size_t item_size2elemfirst=sizeof(int);
24086 size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
24087 size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
24088 size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
24089 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
24090 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
24091 size_t total_item_size0=item_size1elem;
24092 hasher_.Clear();
24093 hasher_.Update(val0);
24094 Digest key0 = hasher_.digest();
24095 hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
24096 hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
24097 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
24098 hvl_t buf0 = VLValToBuf(val0);
24099 AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0);
24100 InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
24101 }
24102 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24103}
24104template<>
24105void Hdf5Back::WriteToBuf<PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24106 std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24107 size_t item_size0=((shape[1]+((sizeof(double))*shape[2])));
24108 size_t item_size1first=shape[1];
24109 size_t valuelen1first;
24110 size_t item_size1second=((sizeof(double))*shape[2]);
24111 size_t length1second=shape[2];
24112 size_t item_size2secondelem=sizeof(double);
24113 size_t total_item_size1second=item_size2secondelem;
24114 size_t total_item_size0=item_size1first+item_size1second;
24115 unsigned int count0=0;
24116 valuelen1first=std::min(val0.first.size(), item_size1first);
24117 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
24118 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
24119 unsigned int count1second=0;
24120 std::vector<double>::iterator it1second=val0.second.begin();
24121 for(;it1second!=val0.second.end();++it1second){
24122 memcpy(buf+(count0*total_item_size0)+0+item_size1first+item_size2secondelem*count1second, &(*it1second), item_size2secondelem);
24123 ++count1second;
24124
24125 }
24126 memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
24127}
24128template<>
24129void Hdf5Back::WriteToBuf<PAIR_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24130 std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24131 size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2])));
24132 size_t item_size1first=CYCLUS_SHA1_SIZE;
24133 size_t item_size1second=((sizeof(double))*shape[2]);
24134 size_t length1second=shape[2];
24135 size_t item_size2secondelem=sizeof(double);
24136 size_t total_item_size1second=item_size2secondelem;
24137 size_t total_item_size0=item_size1first+item_size1second;
24138 unsigned int count0=0;
24139 hasher_.Clear();
24140 hasher_.Update(val0.first);
24141 Digest key1first = hasher_.digest();
24142 hid_t keysds1first = VLDataset(VL_STRING, true);
24143 hid_t valsds1first = VLDataset(VL_STRING, false);
24144 if (vlkeys_[VL_STRING].count(key1first) != 1) {
24145 AppendVLKey(keysds1first, VL_STRING, key1first);
24146 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
24147 }
24148 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
24149 unsigned int count1second=0;
24150 std::vector<double>::iterator it1second=val0.second.begin();
24151 for(;it1second!=val0.second.end();++it1second){
24152 memcpy(buf+(count0*total_item_size0)+0+item_size1first+item_size2secondelem*count1second, &(*it1second), item_size2secondelem);
24153 ++count1second;
24154
24155 }
24156 memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
24157}
24158template<>
24159void Hdf5Back::WriteToBuf<PAIR_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24160 std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24161 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE)));
24162 size_t item_size1first=shape[1];
24163 size_t valuelen1first;
24164 size_t item_size1second=(CYCLUS_SHA1_SIZE);
24165 size_t item_size2secondelem=sizeof(double);
24166 size_t total_item_size1second=item_size2secondelem;
24167 size_t total_item_size0=item_size1first+item_size1second;
24168 unsigned int count0=0;
24169 valuelen1first=std::min(val0.first.size(), item_size1first);
24170 memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
24171 memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
24172 hasher_.Clear();
24173 hasher_.Update(val0.second);
24174 Digest key1second = hasher_.digest();
24175 hid_t keysds1second = VLDataset(VL_VECTOR_DOUBLE, true);
24176 hid_t valsds1second = VLDataset(VL_VECTOR_DOUBLE, false);
24177 if (vlkeys_[VL_VECTOR_DOUBLE].count(key1second) != 1) {
24178 hvl_t buf1second = VLValToBuf(val0.second);
24179 AppendVLKey(keysds1second, VL_VECTOR_DOUBLE, key1second);
24180 InsertVLVal(valsds1second, VL_VECTOR_DOUBLE, key1second, buf1second);
24181 }
24182 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
24183}
24184template<>
24185void Hdf5Back::WriteToBuf<PAIR_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24186 std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24187 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
24188 size_t item_size1first=CYCLUS_SHA1_SIZE;
24189 size_t item_size1second=(CYCLUS_SHA1_SIZE);
24190 size_t item_size2secondelem=sizeof(double);
24191 size_t total_item_size1second=item_size2secondelem;
24192 size_t total_item_size0=item_size1first+item_size1second;
24193 unsigned int count0=0;
24194 hasher_.Clear();
24195 hasher_.Update(val0.first);
24196 Digest key1first = hasher_.digest();
24197 hid_t keysds1first = VLDataset(VL_STRING, true);
24198 hid_t valsds1first = VLDataset(VL_STRING, false);
24199 if (vlkeys_[VL_STRING].count(key1first) != 1) {
24200 AppendVLKey(keysds1first, VL_STRING, key1first);
24201 InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
24202 }
24203 memcpy(buf+(count0*total_item_size0)+0, key1first.data(), CYCLUS_SHA1_SIZE);
24204 hasher_.Clear();
24205 hasher_.Update(val0.second);
24206 Digest key1second = hasher_.digest();
24207 hid_t keysds1second = VLDataset(VL_VECTOR_DOUBLE, true);
24208 hid_t valsds1second = VLDataset(VL_VECTOR_DOUBLE, false);
24209 if (vlkeys_[VL_VECTOR_DOUBLE].count(key1second) != 1) {
24210 hvl_t buf1second = VLValToBuf(val0.second);
24211 AppendVLKey(keysds1second, VL_VECTOR_DOUBLE, key1second);
24212 InsertVLVal(valsds1second, VL_VECTOR_DOUBLE, key1second, buf1second);
24213 }
24214 memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.data(), CYCLUS_SHA1_SIZE);
24215}
24216template<>
24217void Hdf5Back::WriteToBuf<MAP_PAIR_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24218 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24219 size_t item_size0=((((shape[2]+shape[3]))+sizeof(int))*shape[0]);
24220 size_t length0=shape[0];
24221 size_t item_size1key=((shape[2]+shape[3]));
24222 size_t item_size2keyfirst=shape[2];
24223 size_t valuelen2keyfirst;
24224 size_t item_size2keysecond=shape[3];
24225 size_t valuelen2keysecond;
24226 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24227 size_t item_size1val=sizeof(int);
24228 size_t total_item_size0=item_size1key+item_size1val;
24229 if(total_item_size0*val0.size()>column){
24230 std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24231 std::advance(eraseit, column/total_item_size0);
24232 val0.erase(eraseit,val0.end());
24233
24234 }
24235 unsigned int count0=0;
24236 std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24237 for(;it0!=val0.end();++it0){
24238 unsigned int count1key=0;
24239 valuelen2keyfirst=std::min(it0->first.first.size(), item_size2keyfirst);
24240 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, it0->first.first.c_str(), valuelen2keyfirst);
24241 memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+valuelen2keyfirst, 0, item_size2keyfirst-valuelen2keyfirst);
24242 valuelen2keysecond=std::min(it0->first.second.size(), item_size2keysecond);
24243 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, it0->first.second.c_str(), valuelen2keysecond);
24244 memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst+valuelen2keysecond, 0, item_size2keysecond-valuelen2keysecond);
24245 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24246 ++count0;
24247
24248 }
24249 if(total_item_size0*length0<column){
24250 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24251
24252 }
24253}
24254template<>
24255void Hdf5Back::WriteToBuf<MAP_PAIR_STRING_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24256 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24257 size_t item_size0=((((shape[2]+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
24258 size_t length0=shape[0];
24259 size_t item_size1key=((shape[2]+CYCLUS_SHA1_SIZE));
24260 size_t item_size2keyfirst=shape[2];
24261 size_t valuelen2keyfirst;
24262 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24263 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24264 size_t item_size1val=sizeof(int);
24265 size_t total_item_size0=item_size1key+item_size1val;
24266 if(total_item_size0*val0.size()>column){
24267 std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24268 std::advance(eraseit, column/total_item_size0);
24269 val0.erase(eraseit,val0.end());
24270
24271 }
24272 unsigned int count0=0;
24273 std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24274 for(;it0!=val0.end();++it0){
24275 unsigned int count1key=0;
24276 valuelen2keyfirst=std::min(it0->first.first.size(), item_size2keyfirst);
24277 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, it0->first.first.c_str(), valuelen2keyfirst);
24278 memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+valuelen2keyfirst, 0, item_size2keyfirst-valuelen2keyfirst);
24279 hasher_.Clear();
24280 hasher_.Update(it0->first.second);
24281 Digest key2keysecond = hasher_.digest();
24282 hid_t keysds2keysecond = VLDataset(VL_STRING, true);
24283 hid_t valsds2keysecond = VLDataset(VL_STRING, false);
24284 if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
24285 AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
24286 InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
24287 }
24288 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, key2keysecond.data(), CYCLUS_SHA1_SIZE);
24289 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24290 ++count0;
24291
24292 }
24293 if(total_item_size0*length0<column){
24294 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24295
24296 }
24297}
24298template<>
24299void Hdf5Back::WriteToBuf<MAP_PAIR_VL_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24300 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24301 size_t item_size0=((((CYCLUS_SHA1_SIZE+shape[3]))+sizeof(int))*shape[0]);
24302 size_t length0=shape[0];
24303 size_t item_size1key=((CYCLUS_SHA1_SIZE+shape[3]));
24304 size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24305 size_t item_size2keysecond=shape[3];
24306 size_t valuelen2keysecond;
24307 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24308 size_t item_size1val=sizeof(int);
24309 size_t total_item_size0=item_size1key+item_size1val;
24310 if(total_item_size0*val0.size()>column){
24311 std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24312 std::advance(eraseit, column/total_item_size0);
24313 val0.erase(eraseit,val0.end());
24314
24315 }
24316 unsigned int count0=0;
24317 std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24318 for(;it0!=val0.end();++it0){
24319 unsigned int count1key=0;
24320 hasher_.Clear();
24321 hasher_.Update(it0->first.first);
24322 Digest key2keyfirst = hasher_.digest();
24323 hid_t keysds2keyfirst = VLDataset(VL_STRING, true);
24324 hid_t valsds2keyfirst = VLDataset(VL_STRING, false);
24325 if (vlkeys_[VL_STRING].count(key2keyfirst) != 1) {
24326 AppendVLKey(keysds2keyfirst, VL_STRING, key2keyfirst);
24327 InsertVLVal(valsds2keyfirst, VL_STRING, key2keyfirst, it0->first.first);
24328 }
24329 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, key2keyfirst.data(), CYCLUS_SHA1_SIZE);
24330 valuelen2keysecond=std::min(it0->first.second.size(), item_size2keysecond);
24331 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, it0->first.second.c_str(), valuelen2keysecond);
24332 memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst+valuelen2keysecond, 0, item_size2keysecond-valuelen2keysecond);
24333 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24334 ++count0;
24335
24336 }
24337 if(total_item_size0*length0<column){
24338 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24339
24340 }
24341}
24342template<>
24343void Hdf5Back::WriteToBuf<MAP_PAIR_VL_STRING_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24344 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24345 size_t item_size0=((((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
24346 size_t length0=shape[0];
24347 size_t item_size1key=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
24348 size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24349 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24350 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24351 size_t item_size1val=sizeof(int);
24352 size_t total_item_size0=item_size1key+item_size1val;
24353 if(total_item_size0*val0.size()>column){
24354 std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24355 std::advance(eraseit, column/total_item_size0);
24356 val0.erase(eraseit,val0.end());
24357
24358 }
24359 unsigned int count0=0;
24360 std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24361 for(;it0!=val0.end();++it0){
24362 unsigned int count1key=0;
24363 hasher_.Clear();
24364 hasher_.Update(it0->first.first);
24365 Digest key2keyfirst = hasher_.digest();
24366 hid_t keysds2keyfirst = VLDataset(VL_STRING, true);
24367 hid_t valsds2keyfirst = VLDataset(VL_STRING, false);
24368 if (vlkeys_[VL_STRING].count(key2keyfirst) != 1) {
24369 AppendVLKey(keysds2keyfirst, VL_STRING, key2keyfirst);
24370 InsertVLVal(valsds2keyfirst, VL_STRING, key2keyfirst, it0->first.first);
24371 }
24372 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, key2keyfirst.data(), CYCLUS_SHA1_SIZE);
24373 hasher_.Clear();
24374 hasher_.Update(it0->first.second);
24375 Digest key2keysecond = hasher_.digest();
24376 hid_t keysds2keysecond = VLDataset(VL_STRING, true);
24377 hid_t valsds2keysecond = VLDataset(VL_STRING, false);
24378 if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
24379 AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
24380 InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
24381 }
24382 memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, key2keysecond.data(), CYCLUS_SHA1_SIZE);
24383 memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24384 ++count0;
24385
24386 }
24387 if(total_item_size0*length0<column){
24388 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24389
24390 }
24391}
24392template<>
24393void Hdf5Back::WriteToBuf<VL_MAP_PAIR_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24394 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24395 size_t item_size0=(CYCLUS_SHA1_SIZE);
24396 size_t item_size1key=((shape[2]+shape[3]));
24397 size_t item_size2keyfirst=shape[2];
24398 size_t valuelen2keyfirst;
24399 size_t item_size2keysecond=shape[3];
24400 size_t valuelen2keysecond;
24401 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24402 size_t item_size1val=sizeof(int);
24403 size_t total_item_size0=item_size1key+item_size1val;
24404 unsigned int count0=0;
24405 std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24406 std::map<std::pair<std::string, std::string>, int> fixed_val0;
24407 unsigned int pad_count0=0;
24408 for(;it0!=val0.end();++it0){
24409 std::pair<std::string, std::string> child1key;
24410 unsigned int pad_count1key=0;
24411 std::string child2keyfirst=std::string(it0->first.first,0,item_size2keyfirst);
24412 std::string child2keysecond=std::string(it0->first.second,0,item_size2keysecond);
24413 child1key = std::make_pair(child2keyfirst,child2keysecond);
24414 fixed_val0[child1key] = it0->second;
24415 ++pad_count0;
24416
24417 }
24418 hasher_.Clear();
24419 hasher_.Update(fixed_val0);
24420 Digest key0 = hasher_.digest();
24421 hid_t keysds0 = VLDataset(VL_MAP_PAIR_STRING_STRING_INT, true);
24422 hid_t valsds0 = VLDataset(VL_MAP_PAIR_STRING_STRING_INT, false);
24423 if (vlkeys_[VL_MAP_PAIR_STRING_STRING_INT].count(key0) != 1) {
24424 hvl_t buf0 = VLValToBuf(fixed_val0);
24425 AppendVLKey(keysds0, VL_MAP_PAIR_STRING_STRING_INT, key0);
24426 InsertVLVal(valsds0, VL_MAP_PAIR_STRING_STRING_INT, key0, buf0);
24427 }
24428 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24429}
24430template<>
24431void Hdf5Back::WriteToBuf<VL_MAP_PAIR_STRING_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24432 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24433 size_t item_size0=(CYCLUS_SHA1_SIZE);
24434 size_t item_size1key=((shape[2]+CYCLUS_SHA1_SIZE));
24435 size_t item_size2keyfirst=shape[2];
24436 size_t valuelen2keyfirst;
24437 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24438 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24439 size_t item_size1val=sizeof(int);
24440 size_t total_item_size0=item_size1key+item_size1val;
24441 unsigned int count0=0;
24442 std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24443 std::map<std::pair<std::string, std::string>, int> fixed_val0;
24444 unsigned int pad_count0=0;
24445 for(;it0!=val0.end();++it0){
24446 std::pair<std::string, std::string> child1key;
24447 unsigned int pad_count1key=0;
24448 std::string child2keyfirst=std::string(it0->first.first,0,item_size2keyfirst);
24449 child1key = std::make_pair(child2keyfirst,it0->first.second);
24450 fixed_val0[child1key] = it0->second;
24451 ++pad_count0;
24452
24453 }
24454 hasher_.Clear();
24455 hasher_.Update(fixed_val0);
24456 Digest key0 = hasher_.digest();
24457 hid_t keysds0 = VLDataset(VL_MAP_PAIR_STRING_VL_STRING_INT, true);
24458 hid_t valsds0 = VLDataset(VL_MAP_PAIR_STRING_VL_STRING_INT, false);
24459 if (vlkeys_[VL_MAP_PAIR_STRING_VL_STRING_INT].count(key0) != 1) {
24460 hvl_t buf0 = VLValToBuf(fixed_val0);
24461 AppendVLKey(keysds0, VL_MAP_PAIR_STRING_VL_STRING_INT, key0);
24462 InsertVLVal(valsds0, VL_MAP_PAIR_STRING_VL_STRING_INT, key0, buf0);
24463 }
24464 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24465}
24466template<>
24467void Hdf5Back::WriteToBuf<VL_MAP_PAIR_VL_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24468 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24469 size_t item_size0=(CYCLUS_SHA1_SIZE);
24470 size_t item_size1key=((CYCLUS_SHA1_SIZE+shape[3]));
24471 size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24472 size_t item_size2keysecond=shape[3];
24473 size_t valuelen2keysecond;
24474 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24475 size_t item_size1val=sizeof(int);
24476 size_t total_item_size0=item_size1key+item_size1val;
24477 unsigned int count0=0;
24478 std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24479 std::map<std::pair<std::string, std::string>, int> fixed_val0;
24480 unsigned int pad_count0=0;
24481 for(;it0!=val0.end();++it0){
24482 std::pair<std::string, std::string> child1key;
24483 unsigned int pad_count1key=0;
24484 std::string child2keysecond=std::string(it0->first.second,0,item_size2keysecond);
24485 child1key = std::make_pair(it0->first.first,child2keysecond);
24486 fixed_val0[child1key] = it0->second;
24487 ++pad_count0;
24488
24489 }
24490 hasher_.Clear();
24491 hasher_.Update(fixed_val0);
24492 Digest key0 = hasher_.digest();
24493 hid_t keysds0 = VLDataset(VL_MAP_PAIR_VL_STRING_STRING_INT, true);
24494 hid_t valsds0 = VLDataset(VL_MAP_PAIR_VL_STRING_STRING_INT, false);
24495 if (vlkeys_[VL_MAP_PAIR_VL_STRING_STRING_INT].count(key0) != 1) {
24496 hvl_t buf0 = VLValToBuf(fixed_val0);
24497 AppendVLKey(keysds0, VL_MAP_PAIR_VL_STRING_STRING_INT, key0);
24498 InsertVLVal(valsds0, VL_MAP_PAIR_VL_STRING_STRING_INT, key0, buf0);
24499 }
24500 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24501}
24502template<>
24503void 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) {
24504 std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24505 size_t item_size0=(CYCLUS_SHA1_SIZE);
24506 size_t item_size1key=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
24507 size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24508 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24509 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24510 size_t item_size1val=sizeof(int);
24511 size_t total_item_size0=item_size1key+item_size1val;
24512 hasher_.Clear();
24513 hasher_.Update(val0);
24514 Digest key0 = hasher_.digest();
24515 hid_t keysds0 = VLDataset(VL_MAP_PAIR_VL_STRING_VL_STRING_INT, true);
24516 hid_t valsds0 = VLDataset(VL_MAP_PAIR_VL_STRING_VL_STRING_INT, false);
24517 if (vlkeys_[VL_MAP_PAIR_VL_STRING_VL_STRING_INT].count(key0) != 1) {
24518 hvl_t buf0 = VLValToBuf(val0);
24519 AppendVLKey(keysds0, VL_MAP_PAIR_VL_STRING_VL_STRING_INT, key0);
24520 InsertVLVal(valsds0, VL_MAP_PAIR_VL_STRING_VL_STRING_INT, key0, buf0);
24521 }
24522 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24523}
24524template<>
24525void Hdf5Back::WriteToBuf<MAP_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24526 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24527 size_t item_size0=((shape[1]+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
24528 size_t length0=shape[0];
24529 size_t item_size1key=shape[1];
24530 size_t valuelen1key;
24531 size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24532 size_t length1val=shape[2];
24533 size_t item_size2valkey=shape[3];
24534 size_t valuelen2valkey;
24535 size_t item_size2valval=sizeof(double);
24536 size_t total_item_size1val=item_size2valkey+item_size2valval;
24537 size_t total_item_size0=item_size1key+item_size1val;
24538 if(total_item_size0*val0.size()>column){
24539 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24540 std::advance(eraseit, column/total_item_size0);
24541 val0.erase(eraseit,val0.end());
24542
24543 }
24544 unsigned int count0=0;
24545 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24546 for(;it0!=val0.end();++it0){
24547 valuelen1key=std::min(it0->first.size(), item_size1key);
24548 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24549 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24550 unsigned int count1val=0;
24551 std::map<std::string, double>::iterator it1val=it0->second.begin();
24552 for(;it1val!=it0->second.end();++it1val){
24553 valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
24554 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
24555 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
24556 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24557 ++count1val;
24558
24559 }
24560 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24561 ++count0;
24562
24563 }
24564 if(total_item_size0*length0<column){
24565 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24566
24567 }
24568}
24569template<>
24570void Hdf5Back::WriteToBuf<MAP_STRING_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24571 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24572 size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
24573 size_t length0=shape[0];
24574 size_t item_size1key=shape[1];
24575 size_t valuelen1key;
24576 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
24577 size_t length1val=shape[2];
24578 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24579 size_t item_size2valval=sizeof(double);
24580 size_t total_item_size1val=item_size2valkey+item_size2valval;
24581 size_t total_item_size0=item_size1key+item_size1val;
24582 if(total_item_size0*val0.size()>column){
24583 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24584 std::advance(eraseit, column/total_item_size0);
24585 val0.erase(eraseit,val0.end());
24586
24587 }
24588 unsigned int count0=0;
24589 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24590 for(;it0!=val0.end();++it0){
24591 valuelen1key=std::min(it0->first.size(), item_size1key);
24592 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24593 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24594 unsigned int count1val=0;
24595 std::map<std::string, double>::iterator it1val=it0->second.begin();
24596 for(;it1val!=it0->second.end();++it1val){
24597 hasher_.Clear();
24598 hasher_.Update(it1val->first);
24599 Digest key2valkey = hasher_.digest();
24600 hid_t keysds2valkey = VLDataset(VL_STRING, true);
24601 hid_t valsds2valkey = VLDataset(VL_STRING, false);
24602 if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
24603 AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
24604 InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
24605 }
24606 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.data(), CYCLUS_SHA1_SIZE);
24607 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24608 ++count1val;
24609
24610 }
24611 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24612 ++count0;
24613
24614 }
24615 if(total_item_size0*length0<column){
24616 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24617
24618 }
24619}
24620template<>
24621void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24622 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24623 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
24624 size_t length0=shape[0];
24625 size_t item_size1key=shape[1];
24626 size_t valuelen1key;
24627 size_t item_size1val=(CYCLUS_SHA1_SIZE);
24628 size_t item_size2valkey=shape[3];
24629 size_t valuelen2valkey;
24630 size_t item_size2valval=sizeof(double);
24631 size_t total_item_size1val=item_size2valkey+item_size2valval;
24632 size_t total_item_size0=item_size1key+item_size1val;
24633 if(total_item_size0*val0.size()>column){
24634 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24635 std::advance(eraseit, column/total_item_size0);
24636 val0.erase(eraseit,val0.end());
24637
24638 }
24639 unsigned int count0=0;
24640 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24641 for(;it0!=val0.end();++it0){
24642 valuelen1key=std::min(it0->first.size(), item_size1key);
24643 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24644 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24645 unsigned int count1val=0;
24646 std::map<std::string, double>::iterator it1val=it0->second.begin();
24647 std::map<std::string, double> fixed_val1val;
24648 unsigned int pad_count1val=0;
24649 for(;it1val!=it0->second.end();++it1val){
24650 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
24651 fixed_val1val[child2valkey] = it1val->second;
24652 ++pad_count1val;
24653
24654 }
24655 hasher_.Clear();
24656 hasher_.Update(fixed_val1val);
24657 Digest key1val = hasher_.digest();
24658 hid_t keysds1val = VLDataset(VL_MAP_STRING_DOUBLE, true);
24659 hid_t valsds1val = VLDataset(VL_MAP_STRING_DOUBLE, false);
24660 if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1val) != 1) {
24661 hvl_t buf1val = VLValToBuf(fixed_val1val);
24662 AppendVLKey(keysds1val, VL_MAP_STRING_DOUBLE, key1val);
24663 InsertVLVal(valsds1val, VL_MAP_STRING_DOUBLE, key1val, buf1val);
24664 }
24665 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
24666 ++count0;
24667
24668 }
24669 if(total_item_size0*length0<column){
24670 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24671
24672 }
24673}
24674template<>
24675void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24676 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24677 size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
24678 size_t length0=shape[0];
24679 size_t item_size1key=shape[1];
24680 size_t valuelen1key;
24681 size_t item_size1val=(CYCLUS_SHA1_SIZE);
24682 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24683 size_t item_size2valval=sizeof(double);
24684 size_t total_item_size1val=item_size2valkey+item_size2valval;
24685 size_t total_item_size0=item_size1key+item_size1val;
24686 if(total_item_size0*val0.size()>column){
24687 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24688 std::advance(eraseit, column/total_item_size0);
24689 val0.erase(eraseit,val0.end());
24690
24691 }
24692 unsigned int count0=0;
24693 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24694 for(;it0!=val0.end();++it0){
24695 valuelen1key=std::min(it0->first.size(), item_size1key);
24696 memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24697 memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24698 hasher_.Clear();
24699 hasher_.Update(it0->second);
24700 Digest key1val = hasher_.digest();
24701 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
24702 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
24703 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
24704 hvl_t buf1val = VLValToBuf(it0->second);
24705 AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
24706 InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
24707 }
24708 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
24709 ++count0;
24710
24711 }
24712 if(total_item_size0*length0<column){
24713 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24714
24715 }
24716}
24717template<>
24718void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24719 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24720 size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
24721 size_t length0=shape[0];
24722 size_t item_size1key=CYCLUS_SHA1_SIZE;
24723 size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24724 size_t length1val=shape[2];
24725 size_t item_size2valkey=shape[3];
24726 size_t valuelen2valkey;
24727 size_t item_size2valval=sizeof(double);
24728 size_t total_item_size1val=item_size2valkey+item_size2valval;
24729 size_t total_item_size0=item_size1key+item_size1val;
24730 if(total_item_size0*val0.size()>column){
24731 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24732 std::advance(eraseit, column/total_item_size0);
24733 val0.erase(eraseit,val0.end());
24734
24735 }
24736 unsigned int count0=0;
24737 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24738 for(;it0!=val0.end();++it0){
24739 hasher_.Clear();
24740 hasher_.Update(it0->first);
24741 Digest key1key = hasher_.digest();
24742 hid_t keysds1key = VLDataset(VL_STRING, true);
24743 hid_t valsds1key = VLDataset(VL_STRING, false);
24744 if (vlkeys_[VL_STRING].count(key1key) != 1) {
24745 AppendVLKey(keysds1key, VL_STRING, key1key);
24746 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24747 }
24748 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
24749 unsigned int count1val=0;
24750 std::map<std::string, double>::iterator it1val=it0->second.begin();
24751 for(;it1val!=it0->second.end();++it1val){
24752 valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
24753 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
24754 memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
24755 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24756 ++count1val;
24757
24758 }
24759 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24760 ++count0;
24761
24762 }
24763 if(total_item_size0*length0<column){
24764 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24765
24766 }
24767}
24768template<>
24769void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24770 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24771 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
24772 size_t length0=shape[0];
24773 size_t item_size1key=CYCLUS_SHA1_SIZE;
24774 size_t item_size1val=(CYCLUS_SHA1_SIZE);
24775 size_t item_size2valkey=shape[3];
24776 size_t valuelen2valkey;
24777 size_t item_size2valval=sizeof(double);
24778 size_t total_item_size1val=item_size2valkey+item_size2valval;
24779 size_t total_item_size0=item_size1key+item_size1val;
24780 if(total_item_size0*val0.size()>column){
24781 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24782 std::advance(eraseit, column/total_item_size0);
24783 val0.erase(eraseit,val0.end());
24784
24785 }
24786 unsigned int count0=0;
24787 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24788 for(;it0!=val0.end();++it0){
24789 hasher_.Clear();
24790 hasher_.Update(it0->first);
24791 Digest key1key = hasher_.digest();
24792 hid_t keysds1key = VLDataset(VL_STRING, true);
24793 hid_t valsds1key = VLDataset(VL_STRING, false);
24794 if (vlkeys_[VL_STRING].count(key1key) != 1) {
24795 AppendVLKey(keysds1key, VL_STRING, key1key);
24796 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24797 }
24798 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
24799 unsigned int count1val=0;
24800 std::map<std::string, double>::iterator it1val=it0->second.begin();
24801 std::map<std::string, double> fixed_val1val;
24802 unsigned int pad_count1val=0;
24803 for(;it1val!=it0->second.end();++it1val){
24804 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
24805 fixed_val1val[child2valkey] = it1val->second;
24806 ++pad_count1val;
24807
24808 }
24809 hasher_.Clear();
24810 hasher_.Update(fixed_val1val);
24811 Digest key1val = hasher_.digest();
24812 hid_t keysds1val = VLDataset(VL_MAP_STRING_DOUBLE, true);
24813 hid_t valsds1val = VLDataset(VL_MAP_STRING_DOUBLE, false);
24814 if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1val) != 1) {
24815 hvl_t buf1val = VLValToBuf(fixed_val1val);
24816 AppendVLKey(keysds1val, VL_MAP_STRING_DOUBLE, key1val);
24817 InsertVLVal(valsds1val, VL_MAP_STRING_DOUBLE, key1val, buf1val);
24818 }
24819 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
24820 ++count0;
24821
24822 }
24823 if(total_item_size0*length0<column){
24824 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24825
24826 }
24827}
24828template<>
24829void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24830 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24831 size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
24832 size_t length0=shape[0];
24833 size_t item_size1key=CYCLUS_SHA1_SIZE;
24834 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
24835 size_t length1val=shape[2];
24836 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24837 size_t item_size2valval=sizeof(double);
24838 size_t total_item_size1val=item_size2valkey+item_size2valval;
24839 size_t total_item_size0=item_size1key+item_size1val;
24840 if(total_item_size0*val0.size()>column){
24841 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24842 std::advance(eraseit, column/total_item_size0);
24843 val0.erase(eraseit,val0.end());
24844
24845 }
24846 unsigned int count0=0;
24847 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24848 for(;it0!=val0.end();++it0){
24849 hasher_.Clear();
24850 hasher_.Update(it0->first);
24851 Digest key1key = hasher_.digest();
24852 hid_t keysds1key = VLDataset(VL_STRING, true);
24853 hid_t valsds1key = VLDataset(VL_STRING, false);
24854 if (vlkeys_[VL_STRING].count(key1key) != 1) {
24855 AppendVLKey(keysds1key, VL_STRING, key1key);
24856 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24857 }
24858 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
24859 unsigned int count1val=0;
24860 std::map<std::string, double>::iterator it1val=it0->second.begin();
24861 for(;it1val!=it0->second.end();++it1val){
24862 hasher_.Clear();
24863 hasher_.Update(it1val->first);
24864 Digest key2valkey = hasher_.digest();
24865 hid_t keysds2valkey = VLDataset(VL_STRING, true);
24866 hid_t valsds2valkey = VLDataset(VL_STRING, false);
24867 if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
24868 AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
24869 InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
24870 }
24871 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.data(), CYCLUS_SHA1_SIZE);
24872 memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24873 ++count1val;
24874
24875 }
24876 memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24877 ++count0;
24878
24879 }
24880 if(total_item_size0*length0<column){
24881 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24882
24883 }
24884}
24885template<>
24886void 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) {
24887 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24888 size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
24889 size_t length0=shape[0];
24890 size_t item_size1key=CYCLUS_SHA1_SIZE;
24891 size_t item_size1val=(CYCLUS_SHA1_SIZE);
24892 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24893 size_t item_size2valval=sizeof(double);
24894 size_t total_item_size1val=item_size2valkey+item_size2valval;
24895 size_t total_item_size0=item_size1key+item_size1val;
24896 if(total_item_size0*val0.size()>column){
24897 std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24898 std::advance(eraseit, column/total_item_size0);
24899 val0.erase(eraseit,val0.end());
24900
24901 }
24902 unsigned int count0=0;
24903 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24904 for(;it0!=val0.end();++it0){
24905 hasher_.Clear();
24906 hasher_.Update(it0->first);
24907 Digest key1key = hasher_.digest();
24908 hid_t keysds1key = VLDataset(VL_STRING, true);
24909 hid_t valsds1key = VLDataset(VL_STRING, false);
24910 if (vlkeys_[VL_STRING].count(key1key) != 1) {
24911 AppendVLKey(keysds1key, VL_STRING, key1key);
24912 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24913 }
24914 memcpy(buf+(count0*total_item_size0)+0, key1key.data(), CYCLUS_SHA1_SIZE);
24915 hasher_.Clear();
24916 hasher_.Update(it0->second);
24917 Digest key1val = hasher_.digest();
24918 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
24919 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
24920 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
24921 hvl_t buf1val = VLValToBuf(it0->second);
24922 AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
24923 InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
24924 }
24925 memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.data(), CYCLUS_SHA1_SIZE);
24926 ++count0;
24927
24928 }
24929 if(total_item_size0*length0<column){
24930 memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24931
24932 }
24933}
24934template<>
24935void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24936 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24937 size_t item_size0=(CYCLUS_SHA1_SIZE);
24938 size_t item_size1key=shape[1];
24939 size_t valuelen1key;
24940 size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24941 size_t length1val=shape[2];
24942 size_t item_size2valkey=shape[3];
24943 size_t valuelen2valkey;
24944 size_t item_size2valval=sizeof(double);
24945 size_t total_item_size1val=item_size2valkey+item_size2valval;
24946 size_t total_item_size0=item_size1key+item_size1val;
24947 unsigned int count0=0;
24948 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24949 std::map<std::string, std::map<std::string, double>> fixed_val0;
24950 unsigned int pad_count0=0;
24951 for(;it0!=val0.end();++it0){
24952 std::string child1key=std::string(it0->first,0,item_size1key);
24953 std::map<std::string, double> child1val;
24954 unsigned int pad_count1val=0;
24955 std::map<std::string, double>::iterator it1val=it0->second.begin();
24956 for(;it1val!=it0->second.end();++it1val){
24957 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
24958 child1val[child2valkey] = it1val->second;
24959 ++pad_count1val;
24960
24961 }
24962 fixed_val0[child1key] = child1val;
24963 ++pad_count0;
24964
24965 }
24966 hasher_.Clear();
24967 hasher_.Update(fixed_val0);
24968 Digest key0 = hasher_.digest();
24969 hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_STRING_DOUBLE, true);
24970 hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_STRING_DOUBLE, false);
24971 if (vlkeys_[VL_MAP_STRING_MAP_STRING_DOUBLE].count(key0) != 1) {
24972 hvl_t buf0 = VLValToBuf(fixed_val0);
24973 AppendVLKey(keysds0, VL_MAP_STRING_MAP_STRING_DOUBLE, key0);
24974 InsertVLVal(valsds0, VL_MAP_STRING_MAP_STRING_DOUBLE, key0, buf0);
24975 }
24976 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
24977}
24978template<>
24979void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24980 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24981 size_t item_size0=(CYCLUS_SHA1_SIZE);
24982 size_t item_size1key=CYCLUS_SHA1_SIZE;
24983 size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24984 size_t length1val=shape[2];
24985 size_t item_size2valkey=shape[3];
24986 size_t valuelen2valkey;
24987 size_t item_size2valval=sizeof(double);
24988 size_t total_item_size1val=item_size2valkey+item_size2valval;
24989 size_t total_item_size0=item_size1key+item_size1val;
24990 unsigned int count0=0;
24991 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24992 std::map<std::string, std::map<std::string, double>> fixed_val0;
24993 unsigned int pad_count0=0;
24994 for(;it0!=val0.end();++it0){
24995 std::map<std::string, double> child1val;
24996 unsigned int pad_count1val=0;
24997 std::map<std::string, double>::iterator it1val=it0->second.begin();
24998 for(;it1val!=it0->second.end();++it1val){
24999 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
25000 child1val[child2valkey] = it1val->second;
25001 ++pad_count1val;
25002
25003 }
25004 fixed_val0[it0->first] = child1val;
25005 ++pad_count0;
25006
25007 }
25008 hasher_.Clear();
25009 hasher_.Update(fixed_val0);
25010 Digest key0 = hasher_.digest();
25011 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_DOUBLE, true);
25012 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_DOUBLE, false);
25013 if (vlkeys_[VL_MAP_VL_STRING_MAP_STRING_DOUBLE].count(key0) != 1) {
25014 hvl_t buf0 = VLValToBuf(fixed_val0);
25015 AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_STRING_DOUBLE, key0);
25016 InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_STRING_DOUBLE, key0, buf0);
25017 }
25018 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
25019}
25020template<>
25021void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25022 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25023 size_t item_size0=(CYCLUS_SHA1_SIZE);
25024 size_t item_size1key=shape[1];
25025 size_t valuelen1key;
25026 size_t item_size1val=(CYCLUS_SHA1_SIZE);
25027 size_t item_size2valkey=shape[3];
25028 size_t valuelen2valkey;
25029 size_t item_size2valval=sizeof(double);
25030 size_t total_item_size1val=item_size2valkey+item_size2valval;
25031 size_t total_item_size0=item_size1key+item_size1val;
25032 unsigned int count0=0;
25033 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25034 std::map<std::string, std::map<std::string, double>> fixed_val0;
25035 unsigned int pad_count0=0;
25036 for(;it0!=val0.end();++it0){
25037 std::string child1key=std::string(it0->first,0,item_size1key);
25038 std::map<std::string, double> child1val;
25039 unsigned int pad_count1val=0;
25040 std::map<std::string, double>::iterator it1val=it0->second.begin();
25041 for(;it1val!=it0->second.end();++it1val){
25042 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
25043 child1val[child2valkey] = it1val->second;
25044 ++pad_count1val;
25045
25046 }
25047 fixed_val0[child1key] = child1val;
25048 ++pad_count0;
25049
25050 }
25051 hasher_.Clear();
25052 hasher_.Update(fixed_val0);
25053 Digest key0 = hasher_.digest();
25054 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_DOUBLE, true);
25055 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_DOUBLE, false);
25056 if (vlkeys_[VL_MAP_STRING_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
25057 hvl_t buf0 = VLValToBuf(fixed_val0);
25058 AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_STRING_DOUBLE, key0);
25059 InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_STRING_DOUBLE, key0, buf0);
25060 }
25061 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
25062}
25063template<>
25064void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25065 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25066 size_t item_size0=(CYCLUS_SHA1_SIZE);
25067 size_t item_size1key=shape[1];
25068 size_t valuelen1key;
25069 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
25070 size_t length1val=shape[2];
25071 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25072 size_t item_size2valval=sizeof(double);
25073 size_t total_item_size1val=item_size2valkey+item_size2valval;
25074 size_t total_item_size0=item_size1key+item_size1val;
25075 unsigned int count0=0;
25076 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25077 std::map<std::string, std::map<std::string, double>> fixed_val0;
25078 unsigned int pad_count0=0;
25079 for(;it0!=val0.end();++it0){
25080 std::string child1key=std::string(it0->first,0,item_size1key);
25081 std::map<std::string, double> child1val;
25082 unsigned int pad_count1val=0;
25083 std::map<std::string, double>::iterator it1val=it0->second.begin();
25084 for(;it1val!=it0->second.end();++it1val){
25085 child1val[it1val->first] = it1val->second;
25086 ++pad_count1val;
25087
25088 }
25089 fixed_val0[child1key] = child1val;
25090 ++pad_count0;
25091
25092 }
25093 hasher_.Clear();
25094 hasher_.Update(fixed_val0);
25095 Digest key0 = hasher_.digest();
25096 hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_DOUBLE, true);
25097 hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_DOUBLE, false);
25098 if (vlkeys_[VL_MAP_STRING_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25099 hvl_t buf0 = VLValToBuf(fixed_val0);
25100 AppendVLKey(keysds0, VL_MAP_STRING_MAP_VL_STRING_DOUBLE, key0);
25101 InsertVLVal(valsds0, VL_MAP_STRING_MAP_VL_STRING_DOUBLE, key0, buf0);
25102 }
25103 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
25104}
25105template<>
25106void 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) {
25107 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25108 size_t item_size0=(CYCLUS_SHA1_SIZE);
25109 size_t item_size1key=shape[1];
25110 size_t valuelen1key;
25111 size_t item_size1val=(CYCLUS_SHA1_SIZE);
25112 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25113 size_t item_size2valval=sizeof(double);
25114 size_t total_item_size1val=item_size2valkey+item_size2valval;
25115 size_t total_item_size0=item_size1key+item_size1val;
25116 unsigned int count0=0;
25117 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25118 std::map<std::string, std::map<std::string, double>> fixed_val0;
25119 unsigned int pad_count0=0;
25120 for(;it0!=val0.end();++it0){
25121 std::string child1key=std::string(it0->first,0,item_size1key);
25122 fixed_val0[child1key] = it0->second;
25123 ++pad_count0;
25124
25125 }
25126 hasher_.Clear();
25127 hasher_.Update(fixed_val0);
25128 Digest key0 = hasher_.digest();
25129 hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, true);
25130 hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, false);
25131 if (vlkeys_[VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25132 hvl_t buf0 = VLValToBuf(fixed_val0);
25133 AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, key0);
25134 InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
25135 }
25136 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
25137}
25138template<>
25139void 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) {
25140 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25141 size_t item_size0=(CYCLUS_SHA1_SIZE);
25142 size_t item_size1key=CYCLUS_SHA1_SIZE;
25143 size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
25144 size_t length1val=shape[2];
25145 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25146 size_t item_size2valval=sizeof(double);
25147 size_t total_item_size1val=item_size2valkey+item_size2valval;
25148 size_t total_item_size0=item_size1key+item_size1val;
25149 unsigned int count0=0;
25150 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25151 std::map<std::string, std::map<std::string, double>> fixed_val0;
25152 unsigned int pad_count0=0;
25153 for(;it0!=val0.end();++it0){
25154 std::map<std::string, double> child1val;
25155 unsigned int pad_count1val=0;
25156 std::map<std::string, double>::iterator it1val=it0->second.begin();
25157 for(;it1val!=it0->second.end();++it1val){
25158 child1val[it1val->first] = it1val->second;
25159 ++pad_count1val;
25160
25161 }
25162 fixed_val0[it0->first] = child1val;
25163 ++pad_count0;
25164
25165 }
25166 hasher_.Clear();
25167 hasher_.Update(fixed_val0);
25168 Digest key0 = hasher_.digest();
25169 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, true);
25170 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, false);
25171 if (vlkeys_[VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25172 hvl_t buf0 = VLValToBuf(fixed_val0);
25173 AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, key0);
25174 InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, key0, buf0);
25175 }
25176 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
25177}
25178template<>
25179void 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) {
25180 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25181 size_t item_size0=(CYCLUS_SHA1_SIZE);
25182 size_t item_size1key=CYCLUS_SHA1_SIZE;
25183 size_t item_size1val=(CYCLUS_SHA1_SIZE);
25184 size_t item_size2valkey=shape[3];
25185 size_t valuelen2valkey;
25186 size_t item_size2valval=sizeof(double);
25187 size_t total_item_size1val=item_size2valkey+item_size2valval;
25188 size_t total_item_size0=item_size1key+item_size1val;
25189 unsigned int count0=0;
25190 std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25191 std::map<std::string, std::map<std::string, double>> fixed_val0;
25192 unsigned int pad_count0=0;
25193 for(;it0!=val0.end();++it0){
25194 std::map<std::string, double> child1val;
25195 unsigned int pad_count1val=0;
25196 std::map<std::string, double>::iterator it1val=it0->second.begin();
25197 for(;it1val!=it0->second.end();++it1val){
25198 std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
25199 child1val[child2valkey] = it1val->second;
25200 ++pad_count1val;
25201
25202 }
25203 fixed_val0[it0->first] = child1val;
25204 ++pad_count0;
25205
25206 }
25207 hasher_.Clear();
25208 hasher_.Update(fixed_val0);
25209 Digest key0 = hasher_.digest();
25210 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, true);
25211 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, false);
25212 if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
25213 hvl_t buf0 = VLValToBuf(fixed_val0);
25214 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, key0);
25215 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, key0, buf0);
25216 }
25217 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
25218}
25219template<>
25220void 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) {
25221 std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25222 size_t item_size0=(CYCLUS_SHA1_SIZE);
25223 size_t item_size1key=CYCLUS_SHA1_SIZE;
25224 size_t item_size1val=(CYCLUS_SHA1_SIZE);
25225 size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25226 size_t item_size2valval=sizeof(double);
25227 size_t total_item_size1val=item_size2valkey+item_size2valval;
25228 size_t total_item_size0=item_size1key+item_size1val;
25229 hasher_.Clear();
25230 hasher_.Update(val0);
25231 Digest key0 = hasher_.digest();
25232 hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, true);
25233 hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, false);
25234 if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25235 hvl_t buf0 = VLValToBuf(val0);
25236 AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, key0);
25237 InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
25238 }
25239 memcpy(buf, key0.data(), CYCLUS_SHA1_SIZE);
25240}
25241
25242
25243
25244void Hdf5Back::FillBuf(std::string title, char* buf, DatumList& group,
25245 size_t* sizes, size_t rowsize) {
25246 using std::min;
25247 using std::string;
25248 using std::vector;
25249 using std::set;
25250 using std::list;
25251 using std::pair;
25252 using std::map;
25253 Datum::Vals vals;
25254 Datum::Shape shape;
25255 Datum::Shapes shapes;
25256 Datum::Vals header = group.front()->vals();
25257 int ncols = header.size();
25258 DbTypes* dbtypes = schemas_[title];
25259
25260 size_t offset = 0;
25261 const void* val;
25262 size_t fieldlen;
25263 size_t valuelen;
25264 DatumList::iterator it;
25265 for (it = group.begin(); it != group.end(); ++it) {
25266 vals = (*it)->vals();
25267 shapes = (*it)->shapes();
25268 for (int col = 0; col < ncols; ++col) {
25269 const boost::spirit::hold_any* a = &(vals[col].second);
25270 switch (dbtypes[col]) {
25271 case BOOL: {
25272 WriteToBuf<BOOL>(buf+offset, shapes[col], a, sizes[col]);
25273 break;
25274
25275 }
25276 case INT: {
25277 WriteToBuf<INT>(buf+offset, shapes[col], a, sizes[col]);
25278 break;
25279
25280 }
25281 case FLOAT: {
25282 WriteToBuf<FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25283 break;
25284
25285 }
25286 case DOUBLE: {
25287 WriteToBuf<DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25288 break;
25289
25290 }
25291 case STRING: {
25292 WriteToBuf<STRING>(buf+offset, shapes[col], a, sizes[col]);
25293 break;
25294
25295 }
25296 case VL_STRING: {
25297 WriteToBuf<VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25298 break;
25299
25300 }
25301 case BLOB: {
25302 WriteToBuf<BLOB>(buf+offset, shapes[col], a, sizes[col]);
25303 break;
25304
25305 }
25306 case UUID: {
25307 WriteToBuf<UUID>(buf+offset, shapes[col], a, sizes[col]);
25308 break;
25309
25310 }
25311 case VECTOR_INT: {
25312 WriteToBuf<VECTOR_INT>(buf+offset, shapes[col], a, sizes[col]);
25313 break;
25314
25315 }
25316 case VL_VECTOR_INT: {
25317 WriteToBuf<VL_VECTOR_INT>(buf+offset, shapes[col], a, sizes[col]);
25318 break;
25319
25320 }
25321 case VECTOR_FLOAT: {
25322 WriteToBuf<VECTOR_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25323 break;
25324
25325 }
25326 case VL_VECTOR_FLOAT: {
25327 WriteToBuf<VL_VECTOR_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25328 break;
25329
25330 }
25331 case VECTOR_DOUBLE: {
25332 WriteToBuf<VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25333 break;
25334
25335 }
25336 case VL_VECTOR_DOUBLE: {
25337 WriteToBuf<VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25338 break;
25339
25340 }
25341 case VECTOR_STRING: {
25342 WriteToBuf<VECTOR_STRING>(buf+offset, shapes[col], a, sizes[col]);
25343 break;
25344
25345 }
25346 case VL_VECTOR_STRING: {
25347 WriteToBuf<VL_VECTOR_STRING>(buf+offset, shapes[col], a, sizes[col]);
25348 break;
25349
25350 }
25351 case VECTOR_VL_STRING: {
25352 WriteToBuf<VECTOR_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25353 break;
25354
25355 }
25356 case VL_VECTOR_VL_STRING: {
25357 WriteToBuf<VL_VECTOR_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25358 break;
25359
25360 }
25361 case VECTOR_BLOB: {
25362 WriteToBuf<VECTOR_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25363 break;
25364
25365 }
25366 case VL_VECTOR_BLOB: {
25367 WriteToBuf<VL_VECTOR_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25368 break;
25369
25370 }
25371 case VECTOR_UUID: {
25372 WriteToBuf<VECTOR_UUID>(buf+offset, shapes[col], a, sizes[col]);
25373 break;
25374
25375 }
25376 case VL_VECTOR_UUID: {
25377 WriteToBuf<VL_VECTOR_UUID>(buf+offset, shapes[col], a, sizes[col]);
25378 break;
25379
25380 }
25381 case SET_INT: {
25382 WriteToBuf<SET_INT>(buf+offset, shapes[col], a, sizes[col]);
25383 break;
25384
25385 }
25386 case VL_SET_INT: {
25387 WriteToBuf<VL_SET_INT>(buf+offset, shapes[col], a, sizes[col]);
25388 break;
25389
25390 }
25391 case SET_FLOAT: {
25392 WriteToBuf<SET_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25393 break;
25394
25395 }
25396 case VL_SET_FLOAT: {
25397 WriteToBuf<VL_SET_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25398 break;
25399
25400 }
25401 case SET_DOUBLE: {
25402 WriteToBuf<SET_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25403 break;
25404
25405 }
25406 case VL_SET_DOUBLE: {
25407 WriteToBuf<VL_SET_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25408 break;
25409
25410 }
25411 case SET_STRING: {
25412 WriteToBuf<SET_STRING>(buf+offset, shapes[col], a, sizes[col]);
25413 break;
25414
25415 }
25416 case VL_SET_STRING: {
25417 WriteToBuf<VL_SET_STRING>(buf+offset, shapes[col], a, sizes[col]);
25418 break;
25419
25420 }
25421 case SET_VL_STRING: {
25422 WriteToBuf<SET_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25423 break;
25424
25425 }
25426 case VL_SET_VL_STRING: {
25427 WriteToBuf<VL_SET_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25428 break;
25429
25430 }
25431 case SET_BLOB: {
25432 WriteToBuf<SET_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25433 break;
25434
25435 }
25436 case VL_SET_BLOB: {
25437 WriteToBuf<VL_SET_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25438 break;
25439
25440 }
25441 case SET_UUID: {
25442 WriteToBuf<SET_UUID>(buf+offset, shapes[col], a, sizes[col]);
25443 break;
25444
25445 }
25446 case VL_SET_UUID: {
25447 WriteToBuf<VL_SET_UUID>(buf+offset, shapes[col], a, sizes[col]);
25448 break;
25449
25450 }
25451 case LIST_BOOL: {
25452 WriteToBuf<LIST_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25453 break;
25454
25455 }
25456 case VL_LIST_BOOL: {
25457 WriteToBuf<VL_LIST_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25458 break;
25459
25460 }
25461 case LIST_INT: {
25462 WriteToBuf<LIST_INT>(buf+offset, shapes[col], a, sizes[col]);
25463 break;
25464
25465 }
25466 case VL_LIST_INT: {
25467 WriteToBuf<VL_LIST_INT>(buf+offset, shapes[col], a, sizes[col]);
25468 break;
25469
25470 }
25471 case LIST_FLOAT: {
25472 WriteToBuf<LIST_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25473 break;
25474
25475 }
25476 case VL_LIST_FLOAT: {
25477 WriteToBuf<VL_LIST_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25478 break;
25479
25480 }
25481 case LIST_DOUBLE: {
25482 WriteToBuf<LIST_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25483 break;
25484
25485 }
25486 case VL_LIST_DOUBLE: {
25487 WriteToBuf<VL_LIST_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25488 break;
25489
25490 }
25491 case LIST_STRING: {
25492 WriteToBuf<LIST_STRING>(buf+offset, shapes[col], a, sizes[col]);
25493 break;
25494
25495 }
25496 case VL_LIST_STRING: {
25497 WriteToBuf<VL_LIST_STRING>(buf+offset, shapes[col], a, sizes[col]);
25498 break;
25499
25500 }
25501 case LIST_VL_STRING: {
25502 WriteToBuf<LIST_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25503 break;
25504
25505 }
25506 case VL_LIST_VL_STRING: {
25507 WriteToBuf<VL_LIST_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25508 break;
25509
25510 }
25511 case LIST_BLOB: {
25512 WriteToBuf<LIST_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25513 break;
25514
25515 }
25516 case VL_LIST_BLOB: {
25517 WriteToBuf<VL_LIST_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25518 break;
25519
25520 }
25521 case LIST_UUID: {
25522 WriteToBuf<LIST_UUID>(buf+offset, shapes[col], a, sizes[col]);
25523 break;
25524
25525 }
25526 case VL_LIST_UUID: {
25527 WriteToBuf<VL_LIST_UUID>(buf+offset, shapes[col], a, sizes[col]);
25528 break;
25529
25530 }
25531 case PAIR_INT_BOOL: {
25532 WriteToBuf<PAIR_INT_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25533 break;
25534
25535 }
25536 case PAIR_INT_INT: {
25537 WriteToBuf<PAIR_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
25538 break;
25539
25540 }
25541 case PAIR_INT_FLOAT: {
25542 WriteToBuf<PAIR_INT_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25543 break;
25544
25545 }
25546 case PAIR_INT_DOUBLE: {
25547 WriteToBuf<PAIR_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25548 break;
25549
25550 }
25551 case PAIR_INT_STRING: {
25552 WriteToBuf<PAIR_INT_STRING>(buf+offset, shapes[col], a, sizes[col]);
25553 break;
25554
25555 }
25556 case PAIR_INT_VL_STRING: {
25557 WriteToBuf<PAIR_INT_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25558 break;
25559
25560 }
25561 case PAIR_INT_BLOB: {
25562 WriteToBuf<PAIR_INT_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25563 break;
25564
25565 }
25566 case PAIR_INT_UUID: {
25567 WriteToBuf<PAIR_INT_UUID>(buf+offset, shapes[col], a, sizes[col]);
25568 break;
25569
25570 }
25571 case PAIR_STRING_BOOL: {
25572 WriteToBuf<PAIR_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25573 break;
25574
25575 }
25576 case PAIR_STRING_INT: {
25577 WriteToBuf<PAIR_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25578 break;
25579
25580 }
25581 case PAIR_STRING_FLOAT: {
25582 WriteToBuf<PAIR_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25583 break;
25584
25585 }
25586 case PAIR_STRING_DOUBLE: {
25587 WriteToBuf<PAIR_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25588 break;
25589
25590 }
25591 case PAIR_STRING_STRING: {
25592 WriteToBuf<PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25593 break;
25594
25595 }
25596 case PAIR_STRING_VL_STRING: {
25597 WriteToBuf<PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25598 break;
25599
25600 }
25601 case PAIR_STRING_BLOB: {
25602 WriteToBuf<PAIR_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25603 break;
25604
25605 }
25606 case PAIR_STRING_UUID: {
25607 WriteToBuf<PAIR_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25608 break;
25609
25610 }
25611 case PAIR_VL_STRING_BOOL: {
25612 WriteToBuf<PAIR_VL_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25613 break;
25614
25615 }
25616 case PAIR_VL_STRING_INT: {
25617 WriteToBuf<PAIR_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25618 break;
25619
25620 }
25621 case PAIR_VL_STRING_FLOAT: {
25622 WriteToBuf<PAIR_VL_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25623 break;
25624
25625 }
25626 case PAIR_VL_STRING_DOUBLE: {
25627 WriteToBuf<PAIR_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25628 break;
25629
25630 }
25631 case PAIR_VL_STRING_STRING: {
25632 WriteToBuf<PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25633 break;
25634
25635 }
25636 case PAIR_VL_STRING_VL_STRING: {
25637 WriteToBuf<PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25638 break;
25639
25640 }
25641 case PAIR_VL_STRING_BLOB: {
25642 WriteToBuf<PAIR_VL_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25643 break;
25644
25645 }
25646 case PAIR_VL_STRING_UUID: {
25647 WriteToBuf<PAIR_VL_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25648 break;
25649
25650 }
25651 case MAP_INT_BOOL: {
25652 WriteToBuf<MAP_INT_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25653 break;
25654
25655 }
25656 case VL_MAP_INT_BOOL: {
25657 WriteToBuf<VL_MAP_INT_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25658 break;
25659
25660 }
25661 case MAP_INT_INT: {
25662 WriteToBuf<MAP_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
25663 break;
25664
25665 }
25666 case VL_MAP_INT_INT: {
25667 WriteToBuf<VL_MAP_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
25668 break;
25669
25670 }
25671 case MAP_INT_FLOAT: {
25672 WriteToBuf<MAP_INT_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25673 break;
25674
25675 }
25676 case VL_MAP_INT_FLOAT: {
25677 WriteToBuf<VL_MAP_INT_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25678 break;
25679
25680 }
25681 case MAP_INT_DOUBLE: {
25682 WriteToBuf<MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25683 break;
25684
25685 }
25686 case VL_MAP_INT_DOUBLE: {
25687 WriteToBuf<VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25688 break;
25689
25690 }
25691 case MAP_INT_STRING: {
25692 WriteToBuf<MAP_INT_STRING>(buf+offset, shapes[col], a, sizes[col]);
25693 break;
25694
25695 }
25696 case VL_MAP_INT_STRING: {
25697 WriteToBuf<VL_MAP_INT_STRING>(buf+offset, shapes[col], a, sizes[col]);
25698 break;
25699
25700 }
25701 case MAP_INT_VL_STRING: {
25702 WriteToBuf<MAP_INT_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25703 break;
25704
25705 }
25706 case VL_MAP_INT_VL_STRING: {
25707 WriteToBuf<VL_MAP_INT_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25708 break;
25709
25710 }
25711 case MAP_INT_BLOB: {
25712 WriteToBuf<MAP_INT_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25713 break;
25714
25715 }
25716 case VL_MAP_INT_BLOB: {
25717 WriteToBuf<VL_MAP_INT_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25718 break;
25719
25720 }
25721 case MAP_INT_UUID: {
25722 WriteToBuf<MAP_INT_UUID>(buf+offset, shapes[col], a, sizes[col]);
25723 break;
25724
25725 }
25726 case VL_MAP_INT_UUID: {
25727 WriteToBuf<VL_MAP_INT_UUID>(buf+offset, shapes[col], a, sizes[col]);
25728 break;
25729
25730 }
25731 case MAP_STRING_BOOL: {
25732 WriteToBuf<MAP_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25733 break;
25734
25735 }
25736 case VL_MAP_STRING_BOOL: {
25737 WriteToBuf<VL_MAP_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25738 break;
25739
25740 }
25741 case MAP_STRING_INT: {
25742 WriteToBuf<MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25743 break;
25744
25745 }
25746 case VL_MAP_STRING_INT: {
25747 WriteToBuf<VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25748 break;
25749
25750 }
25751 case MAP_STRING_FLOAT: {
25752 WriteToBuf<MAP_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25753 break;
25754
25755 }
25756 case VL_MAP_STRING_FLOAT: {
25757 WriteToBuf<VL_MAP_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25758 break;
25759
25760 }
25761 case MAP_STRING_DOUBLE: {
25762 WriteToBuf<MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25763 break;
25764
25765 }
25766 case VL_MAP_STRING_DOUBLE: {
25767 WriteToBuf<VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25768 break;
25769
25770 }
25771 case MAP_STRING_STRING: {
25772 WriteToBuf<MAP_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25773 break;
25774
25775 }
25776 case VL_MAP_STRING_STRING: {
25777 WriteToBuf<VL_MAP_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25778 break;
25779
25780 }
25781 case MAP_STRING_VL_STRING: {
25782 WriteToBuf<MAP_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25783 break;
25784
25785 }
25786 case VL_MAP_STRING_VL_STRING: {
25787 WriteToBuf<VL_MAP_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25788 break;
25789
25790 }
25791 case MAP_STRING_BLOB: {
25792 WriteToBuf<MAP_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25793 break;
25794
25795 }
25796 case VL_MAP_STRING_BLOB: {
25797 WriteToBuf<VL_MAP_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25798 break;
25799
25800 }
25801 case MAP_STRING_UUID: {
25802 WriteToBuf<MAP_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25803 break;
25804
25805 }
25806 case VL_MAP_STRING_UUID: {
25807 WriteToBuf<VL_MAP_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25808 break;
25809
25810 }
25811 case MAP_VL_STRING_BOOL: {
25812 WriteToBuf<MAP_VL_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25813 break;
25814
25815 }
25816 case VL_MAP_VL_STRING_BOOL: {
25817 WriteToBuf<VL_MAP_VL_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25818 break;
25819
25820 }
25821 case MAP_VL_STRING_INT: {
25822 WriteToBuf<MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25823 break;
25824
25825 }
25826 case VL_MAP_VL_STRING_INT: {
25827 WriteToBuf<VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25828 break;
25829
25830 }
25831 case MAP_VL_STRING_FLOAT: {
25832 WriteToBuf<MAP_VL_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25833 break;
25834
25835 }
25836 case VL_MAP_VL_STRING_FLOAT: {
25837 WriteToBuf<VL_MAP_VL_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25838 break;
25839
25840 }
25841 case MAP_VL_STRING_DOUBLE: {
25842 WriteToBuf<MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25843 break;
25844
25845 }
25846 case VL_MAP_VL_STRING_DOUBLE: {
25847 WriteToBuf<VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25848 break;
25849
25850 }
25851 case MAP_VL_STRING_STRING: {
25852 WriteToBuf<MAP_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25853 break;
25854
25855 }
25856 case VL_MAP_VL_STRING_STRING: {
25857 WriteToBuf<VL_MAP_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25858 break;
25859
25860 }
25861 case MAP_VL_STRING_VL_STRING: {
25862 WriteToBuf<MAP_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25863 break;
25864
25865 }
25866 case VL_MAP_VL_STRING_VL_STRING: {
25867 WriteToBuf<VL_MAP_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25868 break;
25869
25870 }
25871 case MAP_VL_STRING_BLOB: {
25872 WriteToBuf<MAP_VL_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25873 break;
25874
25875 }
25876 case VL_MAP_VL_STRING_BLOB: {
25877 WriteToBuf<VL_MAP_VL_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25878 break;
25879
25880 }
25881 case MAP_VL_STRING_UUID: {
25882 WriteToBuf<MAP_VL_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25883 break;
25884
25885 }
25886 case VL_MAP_VL_STRING_UUID: {
25887 WriteToBuf<VL_MAP_VL_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25888 break;
25889
25890 }
25891 case MAP_PAIR_INT_STRING_DOUBLE: {
25892 WriteToBuf<MAP_PAIR_INT_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25893 break;
25894
25895 }
25896 case VL_MAP_PAIR_INT_STRING_DOUBLE: {
25897 WriteToBuf<VL_MAP_PAIR_INT_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25898 break;
25899
25900 }
25901 case MAP_PAIR_INT_VL_STRING_DOUBLE: {
25902 WriteToBuf<MAP_PAIR_INT_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25903 break;
25904
25905 }
25906 case VL_MAP_PAIR_INT_VL_STRING_DOUBLE: {
25907 WriteToBuf<VL_MAP_PAIR_INT_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25908 break;
25909
25910 }
25911 case MAP_STRING_VECTOR_DOUBLE: {
25912 WriteToBuf<MAP_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25913 break;
25914
25915 }
25916 case MAP_STRING_VL_VECTOR_DOUBLE: {
25917 WriteToBuf<MAP_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25918 break;
25919
25920 }
25921 case VL_MAP_STRING_VECTOR_DOUBLE: {
25922 WriteToBuf<VL_MAP_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25923 break;
25924
25925 }
25926 case MAP_VL_STRING_VECTOR_DOUBLE: {
25927 WriteToBuf<MAP_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25928 break;
25929
25930 }
25931 case MAP_VL_STRING_VL_VECTOR_DOUBLE: {
25932 WriteToBuf<MAP_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25933 break;
25934
25935 }
25936 case VL_MAP_STRING_VL_VECTOR_DOUBLE: {
25937 WriteToBuf<VL_MAP_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25938 break;
25939
25940 }
25941 case VL_MAP_VL_STRING_VECTOR_DOUBLE: {
25942 WriteToBuf<VL_MAP_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25943 break;
25944
25945 }
25946 case VL_MAP_VL_STRING_VL_VECTOR_DOUBLE: {
25947 WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25948 break;
25949
25950 }
25951 case MAP_STRING_MAP_INT_DOUBLE: {
25952 WriteToBuf<MAP_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25953 break;
25954
25955 }
25956 case MAP_STRING_VL_MAP_INT_DOUBLE: {
25957 WriteToBuf<MAP_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25958 break;
25959
25960 }
25961 case VL_MAP_STRING_MAP_INT_DOUBLE: {
25962 WriteToBuf<VL_MAP_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25963 break;
25964
25965 }
25966 case MAP_VL_STRING_MAP_INT_DOUBLE: {
25967 WriteToBuf<MAP_VL_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25968 break;
25969
25970 }
25971 case MAP_VL_STRING_VL_MAP_INT_DOUBLE: {
25972 WriteToBuf<MAP_VL_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25973 break;
25974
25975 }
25976 case VL_MAP_STRING_VL_MAP_INT_DOUBLE: {
25977 WriteToBuf<VL_MAP_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25978 break;
25979
25980 }
25981 case VL_MAP_VL_STRING_MAP_INT_DOUBLE: {
25982 WriteToBuf<VL_MAP_VL_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25983 break;
25984
25985 }
25986 case VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE: {
25987 WriteToBuf<VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25988 break;
25989
25990 }
25991 case MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
25992 WriteToBuf<MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25993 break;
25994
25995 }
25996 case VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
25997 WriteToBuf<VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25998 break;
25999
26000 }
26001 case MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
26002 WriteToBuf<MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26003 break;
26004
26005 }
26006 case MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
26007 WriteToBuf<MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26008 break;
26009
26010 }
26011 case VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
26012 WriteToBuf<VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26013 break;
26014
26015 }
26016 case VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
26017 WriteToBuf<VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26018 break;
26019
26020 }
26021 case MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
26022 WriteToBuf<MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26023 break;
26024
26025 }
26026 case VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
26027 WriteToBuf<VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26028 break;
26029
26030 }
26031 case MAP_INT_MAP_STRING_DOUBLE: {
26032 WriteToBuf<MAP_INT_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26033 break;
26034
26035 }
26036 case MAP_INT_MAP_VL_STRING_DOUBLE: {
26037 WriteToBuf<MAP_INT_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26038 break;
26039
26040 }
26041 case VL_MAP_INT_MAP_STRING_DOUBLE: {
26042 WriteToBuf<VL_MAP_INT_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26043 break;
26044
26045 }
26046 case VL_MAP_INT_MAP_VL_STRING_DOUBLE: {
26047 WriteToBuf<VL_MAP_INT_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26048 break;
26049
26050 }
26051 case MAP_INT_VL_MAP_STRING_DOUBLE: {
26052 WriteToBuf<MAP_INT_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26053 break;
26054
26055 }
26056 case MAP_INT_VL_MAP_VL_STRING_DOUBLE: {
26057 WriteToBuf<MAP_INT_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26058 break;
26059
26060 }
26061 case VL_MAP_INT_VL_MAP_STRING_DOUBLE: {
26062 WriteToBuf<VL_MAP_INT_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26063 break;
26064
26065 }
26066 case VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE: {
26067 WriteToBuf<VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26068 break;
26069
26070 }
26071 case MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26072 WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26073 break;
26074
26075 }
26076 case MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26077 WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26078 break;
26079
26080 }
26081 case MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26082 WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26083 break;
26084
26085 }
26086 case MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26087 WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26088 break;
26089
26090 }
26091 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26092 WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26093 break;
26094
26095 }
26096 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26097 WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26098 break;
26099
26100 }
26101 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26102 WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26103 break;
26104
26105 }
26106 case MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26107 WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26108 break;
26109
26110 }
26111 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26112 WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26113 break;
26114
26115 }
26116 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26117 WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26118 break;
26119
26120 }
26121 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26122 WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26123 break;
26124
26125 }
26126 case MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26127 WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26128 break;
26129
26130 }
26131 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26132 WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26133 break;
26134
26135 }
26136 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26137 WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26138 break;
26139
26140 }
26141 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26142 WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26143 break;
26144
26145 }
26146 case MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26147 WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26148 break;
26149
26150 }
26151 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26152 WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26153 break;
26154
26155 }
26156 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26157 WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26158 break;
26159
26160 }
26161 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26162 WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26163 break;
26164
26165 }
26166 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26167 WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26168 break;
26169
26170 }
26171 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26172 WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26173 break;
26174
26175 }
26176 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26177 WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26178 break;
26179
26180 }
26181 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26182 WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26183 break;
26184
26185 }
26186 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26187 WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26188 break;
26189
26190 }
26191 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26192 WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26193 break;
26194
26195 }
26196 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26197 WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26198 break;
26199
26200 }
26201 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26202 WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26203 break;
26204
26205 }
26206 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26207 WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26208 break;
26209
26210 }
26211 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26212 WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26213 break;
26214
26215 }
26216 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26217 WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26218 break;
26219
26220 }
26221 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26222 WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26223 break;
26224
26225 }
26226 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26227 WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26228 break;
26229
26230 }
26231 case LIST_PAIR_INT_INT: {
26232 WriteToBuf<LIST_PAIR_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
26233 break;
26234
26235 }
26236 case VL_LIST_PAIR_INT_INT: {
26237 WriteToBuf<VL_LIST_PAIR_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
26238 break;
26239
26240 }
26241 case MAP_STRING_PAIR_STRING_VECTOR_DOUBLE: {
26242 WriteToBuf<MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26243 break;
26244
26245 }
26246 case MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
26247 WriteToBuf<MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26248 break;
26249
26250 }
26251 case MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
26252 WriteToBuf<MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26253 break;
26254
26255 }
26256 case MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
26257 WriteToBuf<MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26258 break;
26259
26260 }
26261 case MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE: {
26262 WriteToBuf<MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26263 break;
26264
26265 }
26266 case MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
26267 WriteToBuf<MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26268 break;
26269
26270 }
26271 case MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
26272 WriteToBuf<MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26273 break;
26274
26275 }
26276 case MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
26277 WriteToBuf<MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26278 break;
26279
26280 }
26281 case VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE: {
26282 WriteToBuf<VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26283 break;
26284
26285 }
26286 case VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE: {
26287 WriteToBuf<VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26288 break;
26289
26290 }
26291 case VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
26292 WriteToBuf<VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26293 break;
26294
26295 }
26296 case VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
26297 WriteToBuf<VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26298 break;
26299
26300 }
26301 case VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
26302 WriteToBuf<VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26303 break;
26304
26305 }
26306 case VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
26307 WriteToBuf<VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26308 break;
26309
26310 }
26311 case VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
26312 WriteToBuf<VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26313 break;
26314
26315 }
26316 case VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
26317 WriteToBuf<VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26318 break;
26319
26320 }
26321 case MAP_STRING_MAP_STRING_INT: {
26322 WriteToBuf<MAP_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26323 break;
26324
26325 }
26326 case MAP_STRING_MAP_VL_STRING_INT: {
26327 WriteToBuf<MAP_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26328 break;
26329
26330 }
26331 case MAP_STRING_VL_MAP_STRING_INT: {
26332 WriteToBuf<MAP_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26333 break;
26334
26335 }
26336 case MAP_STRING_VL_MAP_VL_STRING_INT: {
26337 WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26338 break;
26339
26340 }
26341 case MAP_VL_STRING_MAP_STRING_INT: {
26342 WriteToBuf<MAP_VL_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26343 break;
26344
26345 }
26346 case MAP_VL_STRING_VL_MAP_STRING_INT: {
26347 WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26348 break;
26349
26350 }
26351 case MAP_VL_STRING_MAP_VL_STRING_INT: {
26352 WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26353 break;
26354
26355 }
26356 case MAP_VL_STRING_VL_MAP_VL_STRING_INT: {
26357 WriteToBuf<MAP_VL_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26358 break;
26359
26360 }
26361 case VL_MAP_STRING_MAP_STRING_INT: {
26362 WriteToBuf<VL_MAP_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26363 break;
26364
26365 }
26366 case VL_MAP_VL_STRING_MAP_STRING_INT: {
26367 WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26368 break;
26369
26370 }
26371 case VL_MAP_STRING_VL_MAP_STRING_INT: {
26372 WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26373 break;
26374
26375 }
26376 case VL_MAP_STRING_MAP_VL_STRING_INT: {
26377 WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26378 break;
26379
26380 }
26381 case VL_MAP_STRING_VL_MAP_VL_STRING_INT: {
26382 WriteToBuf<VL_MAP_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26383 break;
26384
26385 }
26386 case VL_MAP_VL_STRING_MAP_VL_STRING_INT: {
26387 WriteToBuf<VL_MAP_VL_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26388 break;
26389
26390 }
26391 case VL_MAP_VL_STRING_VL_MAP_STRING_INT: {
26392 WriteToBuf<VL_MAP_VL_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26393 break;
26394
26395 }
26396 case VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT: {
26397 WriteToBuf<VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26398 break;
26399
26400 }
26401 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE: {
26402 WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26403 break;
26404
26405 }
26406 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE: {
26407 WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26408 break;
26409
26410 }
26411 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE: {
26412 WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26413 break;
26414
26415 }
26416 case VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE: {
26417 WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26418 break;
26419
26420 }
26421 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE: {
26422 WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26423 break;
26424
26425 }
26426 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE: {
26427 WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26428 break;
26429
26430 }
26431 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE: {
26432 WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26433 break;
26434
26435 }
26436 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE: {
26437 WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26438 break;
26439
26440 }
26441 case PAIR_INT_PAIR_STRING_STRING: {
26442 WriteToBuf<PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26443 break;
26444
26445 }
26446 case PAIR_INT_PAIR_VL_STRING_STRING: {
26447 WriteToBuf<PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26448 break;
26449
26450 }
26451 case PAIR_INT_PAIR_STRING_VL_STRING: {
26452 WriteToBuf<PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26453 break;
26454
26455 }
26456 case PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26457 WriteToBuf<PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26458 break;
26459
26460 }
26461 case PAIR_DOUBLE_DOUBLE: {
26462 WriteToBuf<PAIR_DOUBLE_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26463 break;
26464
26465 }
26466 case PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE: {
26467 WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26468 break;
26469
26470 }
26471 case PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE: {
26472 WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26473 break;
26474
26475 }
26476 case PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE: {
26477 WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26478 break;
26479
26480 }
26481 case PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE: {
26482 WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26483 break;
26484
26485 }
26486 case PAIR_DOUBLE_MAP_INT_DOUBLE: {
26487 WriteToBuf<PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26488 break;
26489
26490 }
26491 case PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
26492 WriteToBuf<PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26493 break;
26494
26495 }
26496 case VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26497 WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26498 break;
26499
26500 }
26501 case VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26502 WriteToBuf<VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26503 break;
26504
26505 }
26506 case VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26507 WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26508 break;
26509
26510 }
26511 case VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26512 WriteToBuf<VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26513 break;
26514
26515 }
26516 case VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
26517 WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26518 break;
26519
26520 }
26521 case VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
26522 WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26523 break;
26524
26525 }
26526 case VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
26527 WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26528 break;
26529
26530 }
26531 case VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
26532 WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26533 break;
26534
26535 }
26536 case PAIR_STRING_VECTOR_DOUBLE: {
26537 WriteToBuf<PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26538 break;
26539
26540 }
26541 case PAIR_VL_STRING_VECTOR_DOUBLE: {
26542 WriteToBuf<PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26543 break;
26544
26545 }
26546 case PAIR_STRING_VL_VECTOR_DOUBLE: {
26547 WriteToBuf<PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26548 break;
26549
26550 }
26551 case PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
26552 WriteToBuf<PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26553 break;
26554
26555 }
26556 case MAP_PAIR_STRING_STRING_INT: {
26557 WriteToBuf<MAP_PAIR_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26558 break;
26559
26560 }
26561 case MAP_PAIR_STRING_VL_STRING_INT: {
26562 WriteToBuf<MAP_PAIR_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26563 break;
26564
26565 }
26566 case MAP_PAIR_VL_STRING_STRING_INT: {
26567 WriteToBuf<MAP_PAIR_VL_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26568 break;
26569
26570 }
26571 case MAP_PAIR_VL_STRING_VL_STRING_INT: {
26572 WriteToBuf<MAP_PAIR_VL_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26573 break;
26574
26575 }
26576 case VL_MAP_PAIR_STRING_STRING_INT: {
26577 WriteToBuf<VL_MAP_PAIR_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26578 break;
26579
26580 }
26581 case VL_MAP_PAIR_STRING_VL_STRING_INT: {
26582 WriteToBuf<VL_MAP_PAIR_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26583 break;
26584
26585 }
26586 case VL_MAP_PAIR_VL_STRING_STRING_INT: {
26587 WriteToBuf<VL_MAP_PAIR_VL_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26588 break;
26589
26590 }
26591 case VL_MAP_PAIR_VL_STRING_VL_STRING_INT: {
26592 WriteToBuf<VL_MAP_PAIR_VL_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26593 break;
26594
26595 }
26596 case MAP_STRING_MAP_STRING_DOUBLE: {
26597 WriteToBuf<MAP_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26598 break;
26599
26600 }
26601 case MAP_STRING_MAP_VL_STRING_DOUBLE: {
26602 WriteToBuf<MAP_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26603 break;
26604
26605 }
26606 case MAP_STRING_VL_MAP_STRING_DOUBLE: {
26607 WriteToBuf<MAP_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26608 break;
26609
26610 }
26611 case MAP_STRING_VL_MAP_VL_STRING_DOUBLE: {
26612 WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26613 break;
26614
26615 }
26616 case MAP_VL_STRING_MAP_STRING_DOUBLE: {
26617 WriteToBuf<MAP_VL_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26618 break;
26619
26620 }
26621 case MAP_VL_STRING_VL_MAP_STRING_DOUBLE: {
26622 WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26623 break;
26624
26625 }
26626 case MAP_VL_STRING_MAP_VL_STRING_DOUBLE: {
26627 WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26628 break;
26629
26630 }
26631 case MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE: {
26632 WriteToBuf<MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26633 break;
26634
26635 }
26636 case VL_MAP_STRING_MAP_STRING_DOUBLE: {
26637 WriteToBuf<VL_MAP_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26638 break;
26639
26640 }
26641 case VL_MAP_VL_STRING_MAP_STRING_DOUBLE: {
26642 WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26643 break;
26644
26645 }
26646 case VL_MAP_STRING_VL_MAP_STRING_DOUBLE: {
26647 WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26648 break;
26649
26650 }
26651 case VL_MAP_STRING_MAP_VL_STRING_DOUBLE: {
26652 WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26653 break;
26654
26655 }
26656 case VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE: {
26657 WriteToBuf<VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26658 break;
26659
26660 }
26661 case VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE: {
26662 WriteToBuf<VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26663 break;
26664
26665 }
26666 case VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE: {
26667 WriteToBuf<VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26668 break;
26669
26670 }
26671 case VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE: {
26672 WriteToBuf<VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26673 break;
26674
26675 }
26676
26677
26678 default: {
26679 throw ValueError("attempted to retrieve unsupported HDF5 backend type");
26680 }
26681 }
26682 offset += sizes[col];
26683 }
26684 }
26685}
26686
26687template <typename T, DbTypes U>
26688T Hdf5Back::VLRead(const char* rawkey) {
26689 // key is used as offset
26690 Digest key;
26691 memcpy(key.data(), rawkey, CYCLUS_SHA1_SIZE);
26692 const std::vector<hsize_t> idx(key.begin(), key.end());
26693 hid_t dset = VLDataset(U, false);
26694 hid_t dspace = H5Dget_space(dset);
26695 hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, vlchunk_, NULL);
26696 herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, (const hsize_t*) &idx[0],
26697 NULL, vlchunk_, NULL);
26698 if (status < 0)
26699 throw IOError("could not select hyperslab of value array for reading "
26700 "in the database '" + path_ + "'.");
26701 hvl_t buf;
26702 status = H5Dread(dset, vldts_[U], mspace, dspace, H5P_DEFAULT, &buf);
26703 if (status < 0) {
26704 std::stringstream ss;
26705 ss << U;
26706 throw IOError("failed to read in variable length data "
26707 "in the database '" + path_ + "' (type id " + ss.str() +
26708 ").");
26709 }
26710 T val = VLBufToVal<T>(buf);
26711 status = H5Dvlen_reclaim(vldts_[U], mspace, H5P_DEFAULT, &buf);
26712 if (status < 0)
26713 throw IOError("failed to reclaim variable length data space "
26714 "in the database '" + path_ + "'.");
26715 H5Sclose(mspace);
26716 H5Sclose(dspace);
26717 return val;
26718}
26719
26720
26721hid_t Hdf5Back::VLDataset(DbTypes dbtype, bool forkeys) {
26722 std::string name;
26723 switch (dbtype) {
26724 case VL_STRING: {
26725 name="String";
26726 break;
26727
26728 }
26729 case BLOB: {
26730 name="Blob";
26731 break;
26732
26733 }
26734 case VL_VECTOR_INT: {
26735 name="VectorInt";
26736 break;
26737
26738 }
26739 case VL_VECTOR_FLOAT: {
26740 name="VectorFloat";
26741 break;
26742
26743 }
26744 case VL_VECTOR_DOUBLE: {
26745 name="VectorDouble";
26746 break;
26747
26748 }
26749 case VL_VECTOR_STRING: {
26750 name="VectorString";
26751 break;
26752
26753 }
26754 case VL_VECTOR_VL_STRING: {
26755 name="VectorString";
26756 break;
26757
26758 }
26759 case VL_VECTOR_BLOB: {
26760 name="VectorBlob";
26761 break;
26762
26763 }
26764 case VL_VECTOR_UUID: {
26765 name="VectorUuid";
26766 break;
26767
26768 }
26769 case VL_SET_INT: {
26770 name="SetInt";
26771 break;
26772
26773 }
26774 case VL_SET_FLOAT: {
26775 name="SetFloat";
26776 break;
26777
26778 }
26779 case VL_SET_DOUBLE: {
26780 name="SetDouble";
26781 break;
26782
26783 }
26784 case VL_SET_STRING: {
26785 name="SetString";
26786 break;
26787
26788 }
26789 case VL_SET_VL_STRING: {
26790 name="SetString";
26791 break;
26792
26793 }
26794 case VL_SET_BLOB: {
26795 name="SetBlob";
26796 break;
26797
26798 }
26799 case VL_SET_UUID: {
26800 name="SetUuid";
26801 break;
26802
26803 }
26804 case VL_LIST_BOOL: {
26805 name="ListBool";
26806 break;
26807
26808 }
26809 case VL_LIST_INT: {
26810 name="ListInt";
26811 break;
26812
26813 }
26814 case VL_LIST_FLOAT: {
26815 name="ListFloat";
26816 break;
26817
26818 }
26819 case VL_LIST_DOUBLE: {
26820 name="ListDouble";
26821 break;
26822
26823 }
26824 case VL_LIST_STRING: {
26825 name="ListString";
26826 break;
26827
26828 }
26829 case VL_LIST_VL_STRING: {
26830 name="ListString";
26831 break;
26832
26833 }
26834 case VL_LIST_BLOB: {
26835 name="ListBlob";
26836 break;
26837
26838 }
26839 case VL_LIST_UUID: {
26840 name="ListUuid";
26841 break;
26842
26843 }
26844 case VL_MAP_INT_BOOL: {
26845 name="MapIntBool";
26846 break;
26847
26848 }
26849 case VL_MAP_INT_INT: {
26850 name="MapIntInt";
26851 break;
26852
26853 }
26854 case VL_MAP_INT_FLOAT: {
26855 name="MapIntFloat";
26856 break;
26857
26858 }
26859 case VL_MAP_INT_DOUBLE: {
26860 name="MapIntDouble";
26861 break;
26862
26863 }
26864 case VL_MAP_INT_STRING: {
26865 name="MapIntString";
26866 break;
26867
26868 }
26869 case VL_MAP_INT_VL_STRING: {
26870 name="MapIntString";
26871 break;
26872
26873 }
26874 case VL_MAP_INT_BLOB: {
26875 name="MapIntBlob";
26876 break;
26877
26878 }
26879 case VL_MAP_INT_UUID: {
26880 name="MapIntUuid";
26881 break;
26882
26883 }
26884 case VL_MAP_STRING_BOOL: {
26885 name="MapStringBool";
26886 break;
26887
26888 }
26889 case VL_MAP_VL_STRING_BOOL: {
26890 name="MapStringBool";
26891 break;
26892
26893 }
26894 case VL_MAP_STRING_INT: {
26895 name="MapStringInt";
26896 break;
26897
26898 }
26899 case VL_MAP_VL_STRING_INT: {
26900 name="MapStringInt";
26901 break;
26902
26903 }
26904 case VL_MAP_STRING_FLOAT: {
26905 name="MapStringFloat";
26906 break;
26907
26908 }
26909 case VL_MAP_VL_STRING_FLOAT: {
26910 name="MapStringFloat";
26911 break;
26912
26913 }
26914 case VL_MAP_STRING_DOUBLE: {
26915 name="MapStringDouble";
26916 break;
26917
26918 }
26919 case VL_MAP_VL_STRING_DOUBLE: {
26920 name="MapStringDouble";
26921 break;
26922
26923 }
26924 case VL_MAP_STRING_STRING: {
26925 name="MapStringString";
26926 break;
26927
26928 }
26929 case VL_MAP_STRING_VL_STRING: {
26930 name="MapStringString";
26931 break;
26932
26933 }
26934 case VL_MAP_VL_STRING_STRING: {
26935 name="MapStringString";
26936 break;
26937
26938 }
26939 case VL_MAP_VL_STRING_VL_STRING: {
26940 name="MapStringString";
26941 break;
26942
26943 }
26944 case VL_MAP_STRING_BLOB: {
26945 name="MapStringBlob";
26946 break;
26947
26948 }
26949 case VL_MAP_VL_STRING_BLOB: {
26950 name="MapStringBlob";
26951 break;
26952
26953 }
26954 case VL_MAP_STRING_UUID: {
26955 name="MapStringUuid";
26956 break;
26957
26958 }
26959 case VL_MAP_VL_STRING_UUID: {
26960 name="MapStringUuid";
26961 break;
26962
26963 }
26964 case VL_MAP_PAIR_INT_STRING_DOUBLE: {
26965 name="MapPairIntStringDouble";
26966 break;
26967
26968 }
26969 case VL_MAP_PAIR_INT_VL_STRING_DOUBLE: {
26970 name="MapPairIntStringDouble";
26971 break;
26972
26973 }
26974 case VL_MAP_STRING_VECTOR_DOUBLE: {
26975 name="MapStringVectorDouble";
26976 break;
26977
26978 }
26979 case VL_MAP_STRING_VL_VECTOR_DOUBLE: {
26980 name="MapStringVectorDouble";
26981 break;
26982
26983 }
26984 case VL_MAP_VL_STRING_VECTOR_DOUBLE: {
26985 name="MapStringVectorDouble";
26986 break;
26987
26988 }
26989 case VL_MAP_VL_STRING_VL_VECTOR_DOUBLE: {
26990 name="MapStringVectorDouble";
26991 break;
26992
26993 }
26994 case VL_MAP_STRING_MAP_INT_DOUBLE: {
26995 name="MapStringMapIntDouble";
26996 break;
26997
26998 }
26999 case VL_MAP_STRING_VL_MAP_INT_DOUBLE: {
27000 name="MapStringMapIntDouble";
27001 break;
27002
27003 }
27004 case VL_MAP_VL_STRING_MAP_INT_DOUBLE: {
27005 name="MapStringMapIntDouble";
27006 break;
27007
27008 }
27009 case VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE: {
27010 name="MapStringMapIntDouble";
27011 break;
27012
27013 }
27014 case VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
27015 name="MapStringPairDoubleMapIntDouble";
27016 break;
27017
27018 }
27019 case VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE: {
27020 name="MapStringPairDoubleMapIntDouble";
27021 break;
27022
27023 }
27024 case VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
27025 name="MapStringPairDoubleMapIntDouble";
27026 break;
27027
27028 }
27029 case VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE: {
27030 name="MapStringPairDoubleMapIntDouble";
27031 break;
27032
27033 }
27034 case VL_MAP_INT_MAP_STRING_DOUBLE: {
27035 name="MapIntMapStringDouble";
27036 break;
27037
27038 }
27039 case VL_MAP_INT_MAP_VL_STRING_DOUBLE: {
27040 name="MapIntMapStringDouble";
27041 break;
27042
27043 }
27044 case VL_MAP_INT_VL_MAP_STRING_DOUBLE: {
27045 name="MapIntMapStringDouble";
27046 break;
27047
27048 }
27049 case VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE: {
27050 name="MapIntMapStringDouble";
27051 break;
27052
27053 }
27054 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
27055 name="MapStringVectorPairIntPairStringString";
27056 break;
27057
27058 }
27059 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
27060 name="MapStringVectorPairIntPairStringString";
27061 break;
27062
27063 }
27064 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
27065 name="MapStringVectorPairIntPairStringString";
27066 break;
27067
27068 }
27069 case VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
27070 name="MapStringVectorPairIntPairStringString";
27071 break;
27072
27073 }
27074 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
27075 name="MapStringVectorPairIntPairStringString";
27076 break;
27077
27078 }
27079 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
27080 name="MapStringVectorPairIntPairStringString";
27081 break;
27082
27083 }
27084 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
27085 name="MapStringVectorPairIntPairStringString";
27086 break;
27087
27088 }
27089 case VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
27090 name="MapStringVectorPairIntPairStringString";
27091 break;
27092
27093 }
27094 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
27095 name="MapStringVectorPairIntPairStringString";
27096 break;
27097
27098 }
27099 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
27100 name="MapStringVectorPairIntPairStringString";
27101 break;
27102
27103 }
27104 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
27105 name="MapStringVectorPairIntPairStringString";
27106 break;
27107
27108 }
27109 case VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
27110 name="MapStringVectorPairIntPairStringString";
27111 break;
27112
27113 }
27114 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
27115 name="MapStringVectorPairIntPairStringString";
27116 break;
27117
27118 }
27119 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
27120 name="MapStringVectorPairIntPairStringString";
27121 break;
27122
27123 }
27124 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
27125 name="MapStringVectorPairIntPairStringString";
27126 break;
27127
27128 }
27129 case VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
27130 name="MapStringVectorPairIntPairStringString";
27131 break;
27132
27133 }
27134 case VL_LIST_PAIR_INT_INT: {
27135 name="ListPairIntInt";
27136 break;
27137
27138 }
27139 case VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE: {
27140 name="MapStringPairStringVectorDouble";
27141 break;
27142
27143 }
27144 case VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE: {
27145 name="MapStringPairStringVectorDouble";
27146 break;
27147
27148 }
27149 case VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
27150 name="MapStringPairStringVectorDouble";
27151 break;
27152
27153 }
27154 case VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
27155 name="MapStringPairStringVectorDouble";
27156 break;
27157
27158 }
27159 case VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE: {
27160 name="MapStringPairStringVectorDouble";
27161 break;
27162
27163 }
27164 case VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE: {
27165 name="MapStringPairStringVectorDouble";
27166 break;
27167
27168 }
27169 case VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
27170 name="MapStringPairStringVectorDouble";
27171 break;
27172
27173 }
27174 case VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE: {
27175 name="MapStringPairStringVectorDouble";
27176 break;
27177
27178 }
27179 case VL_MAP_STRING_MAP_STRING_INT: {
27180 name="MapStringMapStringInt";
27181 break;
27182
27183 }
27184 case VL_MAP_VL_STRING_MAP_STRING_INT: {
27185 name="MapStringMapStringInt";
27186 break;
27187
27188 }
27189 case VL_MAP_STRING_VL_MAP_STRING_INT: {
27190 name="MapStringMapStringInt";
27191 break;
27192
27193 }
27194 case VL_MAP_STRING_MAP_VL_STRING_INT: {
27195 name="MapStringMapStringInt";
27196 break;
27197
27198 }
27199 case VL_MAP_STRING_VL_MAP_VL_STRING_INT: {
27200 name="MapStringMapStringInt";
27201 break;
27202
27203 }
27204 case VL_MAP_VL_STRING_MAP_VL_STRING_INT: {
27205 name="MapStringMapStringInt";
27206 break;
27207
27208 }
27209 case VL_MAP_VL_STRING_VL_MAP_STRING_INT: {
27210 name="MapStringMapStringInt";
27211 break;
27212
27213 }
27214 case VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT: {
27215 name="MapStringMapStringInt";
27216 break;
27217
27218 }
27219 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE: {
27220 name="VectorPairPairDoubleDoubleMapStringDouble";
27221 break;
27222
27223 }
27224 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE: {
27225 name="VectorPairPairDoubleDoubleMapStringDouble";
27226 break;
27227
27228 }
27229 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE: {
27230 name="VectorPairPairDoubleDoubleMapStringDouble";
27231 break;
27232
27233 }
27234 case VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE: {
27235 name="VectorPairPairDoubleDoubleMapStringDouble";
27236 break;
27237
27238 }
27239 case VL_VECTOR_PAIR_INT_PAIR_STRING_STRING: {
27240 name="VectorPairIntPairStringString";
27241 break;
27242
27243 }
27244 case VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING: {
27245 name="VectorPairIntPairStringString";
27246 break;
27247
27248 }
27249 case VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING: {
27250 name="VectorPairIntPairStringString";
27251 break;
27252
27253 }
27254 case VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING: {
27255 name="VectorPairIntPairStringString";
27256 break;
27257
27258 }
27259 case VL_MAP_PAIR_STRING_STRING_INT: {
27260 name="MapPairStringStringInt";
27261 break;
27262
27263 }
27264 case VL_MAP_PAIR_STRING_VL_STRING_INT: {
27265 name="MapPairStringStringInt";
27266 break;
27267
27268 }
27269 case VL_MAP_PAIR_VL_STRING_STRING_INT: {
27270 name="MapPairStringStringInt";
27271 break;
27272
27273 }
27274 case VL_MAP_PAIR_VL_STRING_VL_STRING_INT: {
27275 name="MapPairStringStringInt";
27276 break;
27277
27278 }
27279 case VL_MAP_STRING_MAP_STRING_DOUBLE: {
27280 name="MapStringMapStringDouble";
27281 break;
27282
27283 }
27284 case VL_MAP_VL_STRING_MAP_STRING_DOUBLE: {
27285 name="MapStringMapStringDouble";
27286 break;
27287
27288 }
27289 case VL_MAP_STRING_VL_MAP_STRING_DOUBLE: {
27290 name="MapStringMapStringDouble";
27291 break;
27292
27293 }
27294 case VL_MAP_STRING_MAP_VL_STRING_DOUBLE: {
27295 name="MapStringMapStringDouble";
27296 break;
27297
27298 }
27299 case VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE: {
27300 name="MapStringMapStringDouble";
27301 break;
27302
27303 }
27304 case VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE: {
27305 name="MapStringMapStringDouble";
27306 break;
27307
27308 }
27309 case VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE: {
27310 name="MapStringMapStringDouble";
27311 break;
27312
27313 }
27314 case VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE: {
27315 name="MapStringMapStringDouble";
27316 break;
27317
27318 }
27319
27320
27321 default: {
27322 throw IOError("could not determine variable length dataset name.");
27323 break;
27324 }
27325 }
27326 name += forkeys ? "Keys" : "Vals";
27327
27328 // already opened
27329 if (vldatasets_.count(name) > 0)
27330 return vldatasets_[name];
27331
27332 // already in db
27333 hid_t dt;
27334 hid_t dset;
27335 hid_t dspace;
27336 herr_t status;
27337 if (H5Lexists(file_, name.c_str(), H5P_DEFAULT)) {
27338 dset = H5Dopen2(file_, name.c_str(), H5P_DEFAULT);
27339 if (forkeys) {
27340 // read in existing keys to vlkeys_
27341 dspace = H5Dget_space(dset);
27342 unsigned int nkeys = H5Sget_simple_extent_npoints(dspace);
27343 char* buf = new char[CYCLUS_SHA1_SIZE * nkeys];
27344 status = H5Dread(dset, sha1_type_, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
27345 if (status < 0)
27346 throw IOError("failed to read in keys for " + name);
27347 for (int n = 0; n < nkeys; ++n) {
27348 Digest d = Digest();
27349 memcpy(d.data(), buf + (n * CYCLUS_SHA1_SIZE), CYCLUS_SHA1_SIZE);
27350 vlkeys_[dbtype].insert(d);
27351 }
27352 H5Sclose(dspace);
27353 delete[] buf;
27354 } else {
27355 if (vldts_.count(dbtype) == 0) {
27356 dt = H5Dget_type(dset);
27357 if (dt < 0)
27358 throw IOError("failed to read in HDF5 datatype for " + name);
27359 vldts_[dbtype] = dt;
27360 }
27361 }
27362 vldatasets_[name] = dset;
27363 return dset;
27364 }
27365
27366 // doesn't exist at all
27367 hid_t prop;
27368 if (forkeys) {
27369 hsize_t dims[1] = {0};
27370 hsize_t maxdims[1] = {H5S_UNLIMITED};
27371 hsize_t chunkdims[1] = {512}; // this is a 10 kb chunksize
27372 dt = sha1_type_;
27373 dspace = H5Screate_simple(1, dims, maxdims);
27374 prop = H5Pcreate(H5P_DATASET_CREATE);
27375 status = H5Pset_chunk(prop, 1, chunkdims);
27376 if (status < 0)
27377 throw IOError("could not create HDF5 array " + name);
27378 } else {
27379 hsize_t dims[CYCLUS_SHA1_NINT];
27380 std::fill(std::begin(dims), std::end(dims), UINT_MAX);
27381 hsize_t chunkdims[CYCLUS_SHA1_NINT]; // this is a single element
27382 std::fill(std::begin(chunkdims), std::end(chunkdims), 1);
27383 dt = vldts_[dbtype];
27384 dspace = H5Screate_simple(CYCLUS_SHA1_NINT, dims, dims);
27385 prop = H5Pcreate(H5P_DATASET_CREATE);
27386 status = H5Pset_chunk(prop, CYCLUS_SHA1_NINT, chunkdims);
27387 if (status < 0)
27388 throw IOError("could not create HDF5 array " + name);
27389 }
27390 dset = H5Dcreate2(file_, name.c_str(), dt, dspace, H5P_DEFAULT, prop, H5P_DEFAULT);
27391 vldatasets_[name] = dset;
27392 return dset;
27393}
27394
27395void Hdf5Back::AppendVLKey(hid_t dset, DbTypes dbtype, const Digest& key) {
27396 hid_t dspace = H5Dget_space(dset);
27397 hsize_t origlen = H5Sget_simple_extent_npoints(dspace);
27398 hsize_t newlen[1] = {origlen + 1};
27399 hsize_t offset[1] = {origlen};
27400 hsize_t extent[1] = {1};
27401 hid_t mspace = H5Screate_simple(1, extent, NULL);
27402 herr_t status = H5Dextend(dset, newlen);
27403 if (status < 0)
27404 throw IOError("could not resize key array in the database '" + path_ + "'.");
27405 dspace = H5Dget_space(dset);
27406 status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, offset, NULL, extent, NULL);
27407 if (status < 0)
27408 throw IOError("could not select hyperslab of key array "
27409 "in the database '" + path_ + "'.");
27410 status = H5Dwrite(dset, sha1_type_, mspace, dspace, H5P_DEFAULT, key.data());
27411 if (status < 0)
27412 throw IOError("could not write digest to key array "
27413 "in the database '" + path_ + "'.");
27414 H5Sclose(mspace);
27415 H5Sclose(dspace);
27416 vlkeys_[dbtype].insert(key);
27417}
27418
27419void Hdf5Back::InsertVLVal(hid_t dset, DbTypes dbtype, const Digest& key,
27420 const std::string& val) {
27421 hid_t dspace = H5Dget_space(dset);
27422 hsize_t extent[CYCLUS_SHA1_NINT];
27423 std::fill(std::begin(extent), std::end(extent), 1);
27424 hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, extent, NULL);
27425 const std::vector<hsize_t> idx(key.begin(), key.end());
27426 herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, (const hsize_t*) &idx[0],
27427 NULL, extent, NULL);
27428 if (status < 0)
27429 throw IOError("could not select hyperslab of value array "
27430 "in the database '" + path_ + "'.");
27431 const char* buf[1] = {val.c_str()};
27432 status = H5Dwrite(dset, vldts_[dbtype], mspace, dspace, H5P_DEFAULT, buf);
27433 if (status < 0)
27434 throw IOError("could not write string to value array "
27435 "in the database '" + path_ + "'.");
27436 H5Sclose(mspace);
27437 H5Sclose(dspace);
27438}
27439
27440void Hdf5Back::InsertVLVal(hid_t dset, DbTypes dbtype, const Digest& key,
27441 hvl_t buf) {
27442 hid_t dspace = H5Dget_space(dset);
27443 hsize_t extent[CYCLUS_SHA1_NINT];
27444 std::fill(std::begin(extent), std::end(extent), 1);
27445 hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, extent, NULL);
27446 const std::vector<hsize_t> idx(key.begin(), key.end());
27447 herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, (const hsize_t*) &idx[0],
27448 NULL, extent, NULL);
27449 if (status < 0)
27450 throw IOError("could not select hyperslab of value array "
27451 "in the database '" + path_ + "'.");
27452 status = H5Dwrite(dset, vldts_[dbtype], mspace, dspace, H5P_DEFAULT, &buf);
27453 if (status < 0)
27454 throw IOError("could not write variable length data to value array "
27455 "in the database '" + path_ + "'.");
27456 status = H5Dvlen_reclaim(vldts_[dbtype], mspace, H5P_DEFAULT, &buf);
27457 if (status < 0)
27458 throw IOError("could not free variable length buffer "
27459 "in the database '" + path_ + "'.");
27460 H5Sclose(mspace);
27461 H5Sclose(dspace);
27462}
27463
27464hvl_t Hdf5Back::VLValToBuf(const std::vector<int>& x) {
27465 hvl_t buf;
27466 buf.len=x.size();
27467 size_t item_size1elem=sizeof(int);
27468 size_t total_item_size0=item_size1elem;
27469 size_t nbytes=total_item_size0*buf.len;
27470 buf.p=new char[nbytes];
27471 unsigned int count0=0;
27472 std::vector<int>::const_iterator it0=x.begin();
27473 for(;it0!=x.end();++it0){
27474 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27475 ++count0;
27476
27477 }
27478 return buf;
27479}
27480hvl_t Hdf5Back::VLValToBuf(const std::vector<float>& x) {
27481 hvl_t buf;
27482 buf.len=x.size();
27483 size_t item_size1elem=sizeof(float);
27484 size_t total_item_size0=item_size1elem;
27485 size_t nbytes=total_item_size0*buf.len;
27486 buf.p=new char[nbytes];
27487 unsigned int count0=0;
27488 std::vector<float>::const_iterator it0=x.begin();
27489 for(;it0!=x.end();++it0){
27490 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27491 ++count0;
27492
27493 }
27494 return buf;
27495}
27496hvl_t Hdf5Back::VLValToBuf(const std::vector<double>& x) {
27497 hvl_t buf;
27498 buf.len=x.size();
27499 size_t item_size1elem=sizeof(double);
27500 size_t total_item_size0=item_size1elem;
27501 size_t nbytes=total_item_size0*buf.len;
27502 buf.p=new char[nbytes];
27503 unsigned int count0=0;
27504 std::vector<double>::const_iterator it0=x.begin();
27505 for(;it0!=x.end();++it0){
27506 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27507 ++count0;
27508
27509 }
27510 return buf;
27511}
27512hvl_t Hdf5Back::VLValToBuf(const std::vector<std::string>& x) {
27513 hvl_t buf;
27514 buf.len=x.size();
27515 size_t item_size1elem=CYCLUS_SHA1_SIZE;
27516 size_t total_item_size0=item_size1elem;
27517 size_t nbytes=total_item_size0*buf.len;
27518 buf.p=new char[nbytes];
27519 unsigned int count0=0;
27520 std::vector<std::string>::const_iterator it0=x.begin();
27521 for(;it0!=x.end();++it0){
27522 hasher_.Clear();
27523 hasher_.Update((*it0));
27524 Digest key1elem = hasher_.digest();
27525 hid_t keysds1elem = VLDataset(VL_STRING, true);
27526 hid_t valsds1elem = VLDataset(VL_STRING, false);
27527 if (vlkeys_[VL_STRING].count(key1elem) != 1) {
27528 AppendVLKey(keysds1elem, VL_STRING, key1elem);
27529 InsertVLVal(valsds1elem, VL_STRING, key1elem, (*it0));
27530 }
27531 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.data(), item_size1elem);
27532 ++count0;
27533
27534 }
27535 return buf;
27536}
27537hvl_t Hdf5Back::VLValToBuf(const std::vector<cyclus::Blob>& x) {
27538 hvl_t buf;
27539 buf.len=x.size();
27540 size_t item_size1elem=CYCLUS_SHA1_SIZE;
27541 size_t total_item_size0=item_size1elem;
27542 size_t nbytes=total_item_size0*buf.len;
27543 buf.p=new char[nbytes];
27544 unsigned int count0=0;
27545 std::vector<cyclus::Blob>::const_iterator it0=x.begin();
27546 for(;it0!=x.end();++it0){
27547 hasher_.Clear();
27548 hasher_.Update((*it0));
27549 Digest key1elem = hasher_.digest();
27550 hid_t keysds1elem = VLDataset(BLOB, true);
27551 hid_t valsds1elem = VLDataset(BLOB, false);
27552 if (vlkeys_[BLOB].count(key1elem) != 1) {
27553 AppendVLKey(keysds1elem, BLOB, key1elem);
27554 InsertVLVal(valsds1elem, BLOB, key1elem, ((*it0)).str());
27555 }
27556 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.data(), item_size1elem);
27557 ++count0;
27558
27559 }
27560 return buf;
27561}
27562hvl_t Hdf5Back::VLValToBuf(const std::vector<boost::uuids::uuid>& x) {
27563 hvl_t buf;
27564 buf.len=x.size();
27565 size_t item_size1elem=CYCLUS_UUID_SIZE;
27566 size_t total_item_size0=item_size1elem;
27567 size_t nbytes=total_item_size0*buf.len;
27568 buf.p=new char[nbytes];
27569 unsigned int count0=0;
27570 std::vector<boost::uuids::uuid>::const_iterator it0=x.begin();
27571 for(;it0!=x.end();++it0){
27572 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27573 ++count0;
27574
27575 }
27576 return buf;
27577}
27578hvl_t Hdf5Back::VLValToBuf(const std::set<int>& x) {
27579 hvl_t buf;
27580 buf.len=x.size();
27581 size_t item_size1elem=sizeof(int);
27582 size_t total_item_size0=item_size1elem;
27583 size_t nbytes=total_item_size0*buf.len;
27584 buf.p=new char[nbytes];
27585 unsigned int count0=0;
27586 std::set<int>::const_iterator it0=x.begin();
27587 for(;it0!=x.end();++it0){
27588 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27589 ++count0;
27590
27591 }
27592 return buf;
27593}
27594hvl_t Hdf5Back::VLValToBuf(const std::set<float>& x) {
27595 hvl_t buf;
27596 buf.len=x.size();
27597 size_t item_size1elem=sizeof(float);
27598 size_t total_item_size0=item_size1elem;
27599 size_t nbytes=total_item_size0*buf.len;
27600 buf.p=new char[nbytes];
27601 unsigned int count0=0;
27602 std::set<float>::const_iterator it0=x.begin();
27603 for(;it0!=x.end();++it0){
27604 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27605 ++count0;
27606
27607 }
27608 return buf;
27609}
27610hvl_t Hdf5Back::VLValToBuf(const std::set<double>& x) {
27611 hvl_t buf;
27612 buf.len=x.size();
27613 size_t item_size1elem=sizeof(double);
27614 size_t total_item_size0=item_size1elem;
27615 size_t nbytes=total_item_size0*buf.len;
27616 buf.p=new char[nbytes];
27617 unsigned int count0=0;
27618 std::set<double>::const_iterator it0=x.begin();
27619 for(;it0!=x.end();++it0){
27620 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27621 ++count0;
27622
27623 }
27624 return buf;
27625}
27626hvl_t Hdf5Back::VLValToBuf(const std::set<std::string>& x) {
27627 hvl_t buf;
27628 buf.len=x.size();
27629 size_t item_size1elem=CYCLUS_SHA1_SIZE;
27630 size_t total_item_size0=item_size1elem;
27631 size_t nbytes=total_item_size0*buf.len;
27632 buf.p=new char[nbytes];
27633 unsigned int count0=0;
27634 std::set<std::string>::const_iterator it0=x.begin();
27635 for(;it0!=x.end();++it0){
27636 hasher_.Clear();
27637 hasher_.Update((*it0));
27638 Digest key1elem = hasher_.digest();
27639 hid_t keysds1elem = VLDataset(VL_STRING, true);
27640 hid_t valsds1elem = VLDataset(VL_STRING, false);
27641 if (vlkeys_[VL_STRING].count(key1elem) != 1) {
27642 AppendVLKey(keysds1elem, VL_STRING, key1elem);
27643 InsertVLVal(valsds1elem, VL_STRING, key1elem, (*it0));
27644 }
27645 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.data(), item_size1elem);
27646 ++count0;
27647
27648 }
27649 return buf;
27650}
27651hvl_t Hdf5Back::VLValToBuf(const std::set<cyclus::Blob>& x) {
27652 hvl_t buf;
27653 buf.len=x.size();
27654 size_t item_size1elem=CYCLUS_SHA1_SIZE;
27655 size_t total_item_size0=item_size1elem;
27656 size_t nbytes=total_item_size0*buf.len;
27657 buf.p=new char[nbytes];
27658 unsigned int count0=0;
27659 std::set<cyclus::Blob>::const_iterator it0=x.begin();
27660 for(;it0!=x.end();++it0){
27661 hasher_.Clear();
27662 hasher_.Update((*it0));
27663 Digest key1elem = hasher_.digest();
27664 hid_t keysds1elem = VLDataset(BLOB, true);
27665 hid_t valsds1elem = VLDataset(BLOB, false);
27666 if (vlkeys_[BLOB].count(key1elem) != 1) {
27667 AppendVLKey(keysds1elem, BLOB, key1elem);
27668 InsertVLVal(valsds1elem, BLOB, key1elem, ((*it0)).str());
27669 }
27670 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.data(), item_size1elem);
27671 ++count0;
27672
27673 }
27674 return buf;
27675}
27676hvl_t Hdf5Back::VLValToBuf(const std::set<boost::uuids::uuid>& x) {
27677 hvl_t buf;
27678 buf.len=x.size();
27679 size_t item_size1elem=CYCLUS_UUID_SIZE;
27680 size_t total_item_size0=item_size1elem;
27681 size_t nbytes=total_item_size0*buf.len;
27682 buf.p=new char[nbytes];
27683 unsigned int count0=0;
27684 std::set<boost::uuids::uuid>::const_iterator it0=x.begin();
27685 for(;it0!=x.end();++it0){
27686 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27687 ++count0;
27688
27689 }
27690 return buf;
27691}
27692hvl_t Hdf5Back::VLValToBuf(const std::list<bool>& x) {
27693 hvl_t buf;
27694 buf.len=x.size();
27695 size_t item_size1elem=sizeof(char);
27696 size_t total_item_size0=item_size1elem;
27697 size_t nbytes=total_item_size0*buf.len;
27698 buf.p=new char[nbytes];
27699 unsigned int count0=0;
27700 std::list<bool>::const_iterator it0=x.begin();
27701 for(;it0!=x.end();++it0){
27702 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27703 ++count0;
27704
27705 }
27706 return buf;
27707}
27708hvl_t Hdf5Back::VLValToBuf(const std::list<int>& x) {
27709 hvl_t buf;
27710 buf.len=x.size();
27711 size_t item_size1elem=sizeof(int);
27712 size_t total_item_size0=item_size1elem;
27713 size_t nbytes=total_item_size0*buf.len;
27714 buf.p=new char[nbytes];
27715 unsigned int count0=0;
27716 std::list<int>::const_iterator it0=x.begin();
27717 for(;it0!=x.end();++it0){
27718 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27719 ++count0;
27720
27721 }
27722 return buf;
27723}
27724hvl_t Hdf5Back::VLValToBuf(const std::list<float>& x) {
27725 hvl_t buf;
27726 buf.len=x.size();
27727 size_t item_size1elem=sizeof(float);
27728 size_t total_item_size0=item_size1elem;
27729 size_t nbytes=total_item_size0*buf.len;
27730 buf.p=new char[nbytes];
27731 unsigned int count0=0;
27732 std::list<float>::const_iterator it0=x.begin();
27733 for(;it0!=x.end();++it0){
27734 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27735 ++count0;
27736
27737 }
27738 return buf;
27739}
27740hvl_t Hdf5Back::VLValToBuf(const std::list<double>& x) {
27741 hvl_t buf;
27742 buf.len=x.size();
27743 size_t item_size1elem=sizeof(double);
27744 size_t total_item_size0=item_size1elem;
27745 size_t nbytes=total_item_size0*buf.len;
27746 buf.p=new char[nbytes];
27747 unsigned int count0=0;
27748 std::list<double>::const_iterator it0=x.begin();
27749 for(;it0!=x.end();++it0){
27750 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27751 ++count0;
27752
27753 }
27754 return buf;
27755}
27756hvl_t Hdf5Back::VLValToBuf(const std::list<std::string>& x) {
27757 hvl_t buf;
27758 buf.len=x.size();
27759 size_t item_size1elem=CYCLUS_SHA1_SIZE;
27760 size_t total_item_size0=item_size1elem;
27761 size_t nbytes=total_item_size0*buf.len;
27762 buf.p=new char[nbytes];
27763 unsigned int count0=0;
27764 std::list<std::string>::const_iterator it0=x.begin();
27765 for(;it0!=x.end();++it0){
27766 hasher_.Clear();
27767 hasher_.Update((*it0));
27768 Digest key1elem = hasher_.digest();
27769 hid_t keysds1elem = VLDataset(VL_STRING, true);
27770 hid_t valsds1elem = VLDataset(VL_STRING, false);
27771 if (vlkeys_[VL_STRING].count(key1elem) != 1) {
27772 AppendVLKey(keysds1elem, VL_STRING, key1elem);
27773 InsertVLVal(valsds1elem, VL_STRING, key1elem, (*it0));
27774 }
27775 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.data(), item_size1elem);
27776 ++count0;
27777
27778 }
27779 return buf;
27780}
27781hvl_t Hdf5Back::VLValToBuf(const std::list<cyclus::Blob>& x) {
27782 hvl_t buf;
27783 buf.len=x.size();
27784 size_t item_size1elem=CYCLUS_SHA1_SIZE;
27785 size_t total_item_size0=item_size1elem;
27786 size_t nbytes=total_item_size0*buf.len;
27787 buf.p=new char[nbytes];
27788 unsigned int count0=0;
27789 std::list<cyclus::Blob>::const_iterator it0=x.begin();
27790 for(;it0!=x.end();++it0){
27791 hasher_.Clear();
27792 hasher_.Update((*it0));
27793 Digest key1elem = hasher_.digest();
27794 hid_t keysds1elem = VLDataset(BLOB, true);
27795 hid_t valsds1elem = VLDataset(BLOB, false);
27796 if (vlkeys_[BLOB].count(key1elem) != 1) {
27797 AppendVLKey(keysds1elem, BLOB, key1elem);
27798 InsertVLVal(valsds1elem, BLOB, key1elem, ((*it0)).str());
27799 }
27800 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.data(), item_size1elem);
27801 ++count0;
27802
27803 }
27804 return buf;
27805}
27806hvl_t Hdf5Back::VLValToBuf(const std::list<boost::uuids::uuid>& x) {
27807 hvl_t buf;
27808 buf.len=x.size();
27809 size_t item_size1elem=CYCLUS_UUID_SIZE;
27810 size_t total_item_size0=item_size1elem;
27811 size_t nbytes=total_item_size0*buf.len;
27812 buf.p=new char[nbytes];
27813 unsigned int count0=0;
27814 std::list<boost::uuids::uuid>::const_iterator it0=x.begin();
27815 for(;it0!=x.end();++it0){
27816 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27817 ++count0;
27818
27819 }
27820 return buf;
27821}
27822hvl_t Hdf5Back::VLValToBuf(const std::map<int, bool>& x) {
27823 hvl_t buf;
27824 buf.len=x.size();
27825 size_t item_size1key=sizeof(int);
27826 size_t item_size1val=sizeof(char);
27827 size_t total_item_size0=item_size1key+item_size1val;
27828 size_t nbytes=total_item_size0*buf.len;
27829 buf.p=new char[nbytes];
27830 unsigned int count0=0;
27831 std::map<int, bool>::const_iterator it0=x.begin();
27832 for(;it0!=x.end();++it0){
27833 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27834 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27835 ++count0;
27836
27837 }
27838 return buf;
27839}
27840hvl_t Hdf5Back::VLValToBuf(const std::map<int, int>& x) {
27841 hvl_t buf;
27842 buf.len=x.size();
27843 size_t item_size1key=sizeof(int);
27844 size_t item_size1val=sizeof(int);
27845 size_t total_item_size0=item_size1key+item_size1val;
27846 size_t nbytes=total_item_size0*buf.len;
27847 buf.p=new char[nbytes];
27848 unsigned int count0=0;
27849 std::map<int, int>::const_iterator it0=x.begin();
27850 for(;it0!=x.end();++it0){
27851 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27852 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27853 ++count0;
27854
27855 }
27856 return buf;
27857}
27858hvl_t Hdf5Back::VLValToBuf(const std::map<int, float>& x) {
27859 hvl_t buf;
27860 buf.len=x.size();
27861 size_t item_size1key=sizeof(int);
27862 size_t item_size1val=sizeof(float);
27863 size_t total_item_size0=item_size1key+item_size1val;
27864 size_t nbytes=total_item_size0*buf.len;
27865 buf.p=new char[nbytes];
27866 unsigned int count0=0;
27867 std::map<int, float>::const_iterator it0=x.begin();
27868 for(;it0!=x.end();++it0){
27869 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27870 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27871 ++count0;
27872
27873 }
27874 return buf;
27875}
27876hvl_t Hdf5Back::VLValToBuf(const std::map<int, double>& x) {
27877 hvl_t buf;
27878 buf.len=x.size();
27879 size_t item_size1key=sizeof(int);
27880 size_t item_size1val=sizeof(double);
27881 size_t total_item_size0=item_size1key+item_size1val;
27882 size_t nbytes=total_item_size0*buf.len;
27883 buf.p=new char[nbytes];
27884 unsigned int count0=0;
27885 std::map<int, double>::const_iterator it0=x.begin();
27886 for(;it0!=x.end();++it0){
27887 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27888 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27889 ++count0;
27890
27891 }
27892 return buf;
27893}
27894hvl_t Hdf5Back::VLValToBuf(const std::map<int, std::string>& x) {
27895 hvl_t buf;
27896 buf.len=x.size();
27897 size_t item_size1key=sizeof(int);
27898 size_t item_size1val=CYCLUS_SHA1_SIZE;
27899 size_t total_item_size0=item_size1key+item_size1val;
27900 size_t nbytes=total_item_size0*buf.len;
27901 buf.p=new char[nbytes];
27902 unsigned int count0=0;
27903 std::map<int, std::string>::const_iterator it0=x.begin();
27904 for(;it0!=x.end();++it0){
27905 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27906 hasher_.Clear();
27907 hasher_.Update(it0->second);
27908 Digest key1val = hasher_.digest();
27909 hid_t keysds1val = VLDataset(VL_STRING, true);
27910 hid_t valsds1val = VLDataset(VL_STRING, false);
27911 if (vlkeys_[VL_STRING].count(key1val) != 1) {
27912 AppendVLKey(keysds1val, VL_STRING, key1val);
27913 InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
27914 }
27915 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
27916 ++count0;
27917
27918 }
27919 return buf;
27920}
27921hvl_t Hdf5Back::VLValToBuf(const std::map<int, cyclus::Blob>& x) {
27922 hvl_t buf;
27923 buf.len=x.size();
27924 size_t item_size1key=sizeof(int);
27925 size_t item_size1val=CYCLUS_SHA1_SIZE;
27926 size_t total_item_size0=item_size1key+item_size1val;
27927 size_t nbytes=total_item_size0*buf.len;
27928 buf.p=new char[nbytes];
27929 unsigned int count0=0;
27930 std::map<int, cyclus::Blob>::const_iterator it0=x.begin();
27931 for(;it0!=x.end();++it0){
27932 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27933 hasher_.Clear();
27934 hasher_.Update(it0->second);
27935 Digest key1val = hasher_.digest();
27936 hid_t keysds1val = VLDataset(BLOB, true);
27937 hid_t valsds1val = VLDataset(BLOB, false);
27938 if (vlkeys_[BLOB].count(key1val) != 1) {
27939 AppendVLKey(keysds1val, BLOB, key1val);
27940 InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
27941 }
27942 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
27943 ++count0;
27944
27945 }
27946 return buf;
27947}
27948hvl_t Hdf5Back::VLValToBuf(const std::map<int, boost::uuids::uuid>& x) {
27949 hvl_t buf;
27950 buf.len=x.size();
27951 size_t item_size1key=sizeof(int);
27952 size_t item_size1val=CYCLUS_UUID_SIZE;
27953 size_t total_item_size0=item_size1key+item_size1val;
27954 size_t nbytes=total_item_size0*buf.len;
27955 buf.p=new char[nbytes];
27956 unsigned int count0=0;
27957 std::map<int, boost::uuids::uuid>::const_iterator it0=x.begin();
27958 for(;it0!=x.end();++it0){
27959 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27960 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27961 ++count0;
27962
27963 }
27964 return buf;
27965}
27966hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, bool>& x) {
27967 hvl_t buf;
27968 buf.len=x.size();
27969 size_t item_size1key=CYCLUS_SHA1_SIZE;
27970 size_t item_size1val=sizeof(char);
27971 size_t total_item_size0=item_size1key+item_size1val;
27972 size_t nbytes=total_item_size0*buf.len;
27973 buf.p=new char[nbytes];
27974 unsigned int count0=0;
27975 std::map<std::string, bool>::const_iterator it0=x.begin();
27976 for(;it0!=x.end();++it0){
27977 hasher_.Clear();
27978 hasher_.Update(it0->first);
27979 Digest key1key = hasher_.digest();
27980 hid_t keysds1key = VLDataset(VL_STRING, true);
27981 hid_t valsds1key = VLDataset(VL_STRING, false);
27982 if (vlkeys_[VL_STRING].count(key1key) != 1) {
27983 AppendVLKey(keysds1key, VL_STRING, key1key);
27984 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
27985 }
27986 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
27987 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27988 ++count0;
27989
27990 }
27991 return buf;
27992}
27993hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, int>& x) {
27994 hvl_t buf;
27995 buf.len=x.size();
27996 size_t item_size1key=CYCLUS_SHA1_SIZE;
27997 size_t item_size1val=sizeof(int);
27998 size_t total_item_size0=item_size1key+item_size1val;
27999 size_t nbytes=total_item_size0*buf.len;
28000 buf.p=new char[nbytes];
28001 unsigned int count0=0;
28002 std::map<std::string, int>::const_iterator it0=x.begin();
28003 for(;it0!=x.end();++it0){
28004 hasher_.Clear();
28005 hasher_.Update(it0->first);
28006 Digest key1key = hasher_.digest();
28007 hid_t keysds1key = VLDataset(VL_STRING, true);
28008 hid_t valsds1key = VLDataset(VL_STRING, false);
28009 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28010 AppendVLKey(keysds1key, VL_STRING, key1key);
28011 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28012 }
28013 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28014 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28015 ++count0;
28016
28017 }
28018 return buf;
28019}
28020hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, float>& x) {
28021 hvl_t buf;
28022 buf.len=x.size();
28023 size_t item_size1key=CYCLUS_SHA1_SIZE;
28024 size_t item_size1val=sizeof(float);
28025 size_t total_item_size0=item_size1key+item_size1val;
28026 size_t nbytes=total_item_size0*buf.len;
28027 buf.p=new char[nbytes];
28028 unsigned int count0=0;
28029 std::map<std::string, float>::const_iterator it0=x.begin();
28030 for(;it0!=x.end();++it0){
28031 hasher_.Clear();
28032 hasher_.Update(it0->first);
28033 Digest key1key = hasher_.digest();
28034 hid_t keysds1key = VLDataset(VL_STRING, true);
28035 hid_t valsds1key = VLDataset(VL_STRING, false);
28036 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28037 AppendVLKey(keysds1key, VL_STRING, key1key);
28038 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28039 }
28040 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28041 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28042 ++count0;
28043
28044 }
28045 return buf;
28046}
28047hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, double>& x) {
28048 hvl_t buf;
28049 buf.len=x.size();
28050 size_t item_size1key=CYCLUS_SHA1_SIZE;
28051 size_t item_size1val=sizeof(double);
28052 size_t total_item_size0=item_size1key+item_size1val;
28053 size_t nbytes=total_item_size0*buf.len;
28054 buf.p=new char[nbytes];
28055 unsigned int count0=0;
28056 std::map<std::string, double>::const_iterator it0=x.begin();
28057 for(;it0!=x.end();++it0){
28058 hasher_.Clear();
28059 hasher_.Update(it0->first);
28060 Digest key1key = hasher_.digest();
28061 hid_t keysds1key = VLDataset(VL_STRING, true);
28062 hid_t valsds1key = VLDataset(VL_STRING, false);
28063 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28064 AppendVLKey(keysds1key, VL_STRING, key1key);
28065 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28066 }
28067 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28068 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28069 ++count0;
28070
28071 }
28072 return buf;
28073}
28074hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::string>& x) {
28075 hvl_t buf;
28076 buf.len=x.size();
28077 size_t item_size1key=CYCLUS_SHA1_SIZE;
28078 size_t item_size1val=CYCLUS_SHA1_SIZE;
28079 size_t total_item_size0=item_size1key+item_size1val;
28080 size_t nbytes=total_item_size0*buf.len;
28081 buf.p=new char[nbytes];
28082 unsigned int count0=0;
28083 std::map<std::string, std::string>::const_iterator it0=x.begin();
28084 for(;it0!=x.end();++it0){
28085 hasher_.Clear();
28086 hasher_.Update(it0->first);
28087 Digest key1key = hasher_.digest();
28088 hid_t keysds1key = VLDataset(VL_STRING, true);
28089 hid_t valsds1key = VLDataset(VL_STRING, false);
28090 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28091 AppendVLKey(keysds1key, VL_STRING, key1key);
28092 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28093 }
28094 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28095 hasher_.Clear();
28096 hasher_.Update(it0->second);
28097 Digest key1val = hasher_.digest();
28098 hid_t keysds1val = VLDataset(VL_STRING, true);
28099 hid_t valsds1val = VLDataset(VL_STRING, false);
28100 if (vlkeys_[VL_STRING].count(key1val) != 1) {
28101 AppendVLKey(keysds1val, VL_STRING, key1val);
28102 InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
28103 }
28104 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28105 ++count0;
28106
28107 }
28108 return buf;
28109}
28110hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, cyclus::Blob>& x) {
28111 hvl_t buf;
28112 buf.len=x.size();
28113 size_t item_size1key=CYCLUS_SHA1_SIZE;
28114 size_t item_size1val=CYCLUS_SHA1_SIZE;
28115 size_t total_item_size0=item_size1key+item_size1val;
28116 size_t nbytes=total_item_size0*buf.len;
28117 buf.p=new char[nbytes];
28118 unsigned int count0=0;
28119 std::map<std::string, cyclus::Blob>::const_iterator it0=x.begin();
28120 for(;it0!=x.end();++it0){
28121 hasher_.Clear();
28122 hasher_.Update(it0->first);
28123 Digest key1key = hasher_.digest();
28124 hid_t keysds1key = VLDataset(VL_STRING, true);
28125 hid_t valsds1key = VLDataset(VL_STRING, false);
28126 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28127 AppendVLKey(keysds1key, VL_STRING, key1key);
28128 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28129 }
28130 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28131 hasher_.Clear();
28132 hasher_.Update(it0->second);
28133 Digest key1val = hasher_.digest();
28134 hid_t keysds1val = VLDataset(BLOB, true);
28135 hid_t valsds1val = VLDataset(BLOB, false);
28136 if (vlkeys_[BLOB].count(key1val) != 1) {
28137 AppendVLKey(keysds1val, BLOB, key1val);
28138 InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
28139 }
28140 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28141 ++count0;
28142
28143 }
28144 return buf;
28145}
28146hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, boost::uuids::uuid>& x) {
28147 hvl_t buf;
28148 buf.len=x.size();
28149 size_t item_size1key=CYCLUS_SHA1_SIZE;
28150 size_t item_size1val=CYCLUS_UUID_SIZE;
28151 size_t total_item_size0=item_size1key+item_size1val;
28152 size_t nbytes=total_item_size0*buf.len;
28153 buf.p=new char[nbytes];
28154 unsigned int count0=0;
28155 std::map<std::string, boost::uuids::uuid>::const_iterator it0=x.begin();
28156 for(;it0!=x.end();++it0){
28157 hasher_.Clear();
28158 hasher_.Update(it0->first);
28159 Digest key1key = hasher_.digest();
28160 hid_t keysds1key = VLDataset(VL_STRING, true);
28161 hid_t valsds1key = VLDataset(VL_STRING, false);
28162 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28163 AppendVLKey(keysds1key, VL_STRING, key1key);
28164 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28165 }
28166 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28167 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28168 ++count0;
28169
28170 }
28171 return buf;
28172}
28173hvl_t Hdf5Back::VLValToBuf(const std::map<std::pair<int, std::string>, double>& x) {
28174 hvl_t buf;
28175 buf.len=x.size();
28176 size_t item_size2keyfirst=sizeof(int);
28177 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
28178 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
28179 size_t item_size1key=total_item_size1key;
28180 size_t item_size1val=sizeof(double);
28181 size_t total_item_size0=item_size1key+item_size1val;
28182 size_t nbytes=total_item_size0*buf.len;
28183 buf.p=new char[nbytes];
28184 unsigned int count0=0;
28185 std::map<std::pair<int, std::string>, double>::const_iterator it0=x.begin();
28186 for(;it0!=x.end();++it0){
28187 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first.first), item_size2keyfirst);
28188 hasher_.Clear();
28189 hasher_.Update(it0->first.second);
28190 Digest key2keysecond = hasher_.digest();
28191 hid_t keysds2keysecond = VLDataset(VL_STRING, true);
28192 hid_t valsds2keysecond = VLDataset(VL_STRING, false);
28193 if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
28194 AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
28195 InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
28196 }
28197 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2keyfirst, key2keysecond.data(), item_size2keysecond);
28198 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28199 ++count0;
28200
28201 }
28202 return buf;
28203}
28204hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::vector<double>>& x) {
28205 hvl_t buf;
28206 buf.len=x.size();
28207 size_t item_size1key=CYCLUS_SHA1_SIZE;
28208 size_t item_size1val=CYCLUS_SHA1_SIZE;
28209 size_t total_item_size0=item_size1key+item_size1val;
28210 size_t nbytes=total_item_size0*buf.len;
28211 buf.p=new char[nbytes];
28212 unsigned int count0=0;
28213 std::map<std::string, std::vector<double>>::const_iterator it0=x.begin();
28214 for(;it0!=x.end();++it0){
28215 hasher_.Clear();
28216 hasher_.Update(it0->first);
28217 Digest key1key = hasher_.digest();
28218 hid_t keysds1key = VLDataset(VL_STRING, true);
28219 hid_t valsds1key = VLDataset(VL_STRING, false);
28220 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28221 AppendVLKey(keysds1key, VL_STRING, key1key);
28222 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28223 }
28224 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28225 hasher_.Clear();
28226 hasher_.Update(it0->second);
28227 Digest key1val = hasher_.digest();
28228 hid_t keysds1val = VLDataset(VL_VECTOR_DOUBLE, true);
28229 hid_t valsds1val = VLDataset(VL_VECTOR_DOUBLE, false);
28230 if (vlkeys_[VL_VECTOR_DOUBLE].count(key1val) != 1) {
28231 hvl_t buf1val = VLValToBuf(it0->second);
28232 AppendVLKey(keysds1val, VL_VECTOR_DOUBLE, key1val);
28233 InsertVLVal(valsds1val, VL_VECTOR_DOUBLE, key1val, buf1val);
28234 }
28235 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28236 ++count0;
28237
28238 }
28239 return buf;
28240}
28241hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::map<int, double>>& x) {
28242 hvl_t buf;
28243 buf.len=x.size();
28244 size_t item_size1key=CYCLUS_SHA1_SIZE;
28245 size_t item_size1val=CYCLUS_SHA1_SIZE;
28246 size_t total_item_size0=item_size1key+item_size1val;
28247 size_t nbytes=total_item_size0*buf.len;
28248 buf.p=new char[nbytes];
28249 unsigned int count0=0;
28250 std::map<std::string, std::map<int, double>>::const_iterator it0=x.begin();
28251 for(;it0!=x.end();++it0){
28252 hasher_.Clear();
28253 hasher_.Update(it0->first);
28254 Digest key1key = hasher_.digest();
28255 hid_t keysds1key = VLDataset(VL_STRING, true);
28256 hid_t valsds1key = VLDataset(VL_STRING, false);
28257 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28258 AppendVLKey(keysds1key, VL_STRING, key1key);
28259 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28260 }
28261 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28262 hasher_.Clear();
28263 hasher_.Update(it0->second);
28264 Digest key1val = hasher_.digest();
28265 hid_t keysds1val = VLDataset(VL_MAP_INT_DOUBLE, true);
28266 hid_t valsds1val = VLDataset(VL_MAP_INT_DOUBLE, false);
28267 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1val) != 1) {
28268 hvl_t buf1val = VLValToBuf(it0->second);
28269 AppendVLKey(keysds1val, VL_MAP_INT_DOUBLE, key1val);
28270 InsertVLVal(valsds1val, VL_MAP_INT_DOUBLE, key1val, buf1val);
28271 }
28272 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28273 ++count0;
28274
28275 }
28276 return buf;
28277}
28278hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::pair<double, std::map<int, double>>>& x) {
28279 hvl_t buf;
28280 buf.len=x.size();
28281 size_t item_size2valfirst=sizeof(double);
28282 size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
28283 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
28284 size_t item_size1key=CYCLUS_SHA1_SIZE;
28285 size_t item_size1val=total_item_size1val;
28286 size_t total_item_size0=item_size1key+item_size1val;
28287 size_t nbytes=total_item_size0*buf.len;
28288 buf.p=new char[nbytes];
28289 unsigned int count0=0;
28290 std::map<std::string, std::pair<double, std::map<int, double>>>::const_iterator it0=x.begin();
28291 for(;it0!=x.end();++it0){
28292 hasher_.Clear();
28293 hasher_.Update(it0->first);
28294 Digest key1key = hasher_.digest();
28295 hid_t keysds1key = VLDataset(VL_STRING, true);
28296 hid_t valsds1key = VLDataset(VL_STRING, false);
28297 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28298 AppendVLKey(keysds1key, VL_STRING, key1key);
28299 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28300 }
28301 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28302 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second.first), item_size2valfirst);
28303 hasher_.Clear();
28304 hasher_.Update(it0->second.second);
28305 Digest key2valsecond = hasher_.digest();
28306 hid_t keysds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, true);
28307 hid_t valsds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, false);
28308 if (vlkeys_[VL_MAP_INT_DOUBLE].count(key2valsecond) != 1) {
28309 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
28310 AppendVLKey(keysds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond);
28311 InsertVLVal(valsds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond, buf2valsecond);
28312 }
28313 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key+item_size2valfirst, key2valsecond.data(), item_size2valsecond);
28314 ++count0;
28315
28316 }
28317 return buf;
28318}
28319hvl_t Hdf5Back::VLValToBuf(const std::map<int, std::map<std::string, double>>& x) {
28320 hvl_t buf;
28321 buf.len=x.size();
28322 size_t item_size1key=sizeof(int);
28323 size_t item_size1val=CYCLUS_SHA1_SIZE;
28324 size_t total_item_size0=item_size1key+item_size1val;
28325 size_t nbytes=total_item_size0*buf.len;
28326 buf.p=new char[nbytes];
28327 unsigned int count0=0;
28328 std::map<int, std::map<std::string, double>>::const_iterator it0=x.begin();
28329 for(;it0!=x.end();++it0){
28330 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
28331 hasher_.Clear();
28332 hasher_.Update(it0->second);
28333 Digest key1val = hasher_.digest();
28334 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
28335 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
28336 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
28337 hvl_t buf1val = VLValToBuf(it0->second);
28338 AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
28339 InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
28340 }
28341 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28342 ++count0;
28343
28344 }
28345 return buf;
28346}
28347hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>& x) {
28348 hvl_t buf;
28349 buf.len=x.size();
28350 size_t item_size1key=CYCLUS_SHA1_SIZE;
28351 size_t item_size1val=CYCLUS_SHA1_SIZE;
28352 size_t total_item_size0=item_size1key+item_size1val;
28353 size_t nbytes=total_item_size0*buf.len;
28354 buf.p=new char[nbytes];
28355 unsigned int count0=0;
28356 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::const_iterator it0=x.begin();
28357 for(;it0!=x.end();++it0){
28358 hasher_.Clear();
28359 hasher_.Update(it0->first);
28360 Digest key1key = hasher_.digest();
28361 hid_t keysds1key = VLDataset(VL_STRING, true);
28362 hid_t valsds1key = VLDataset(VL_STRING, false);
28363 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28364 AppendVLKey(keysds1key, VL_STRING, key1key);
28365 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28366 }
28367 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28368 hasher_.Clear();
28369 hasher_.Update(it0->second);
28370 Digest key1val = hasher_.digest();
28371 hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
28372 hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
28373 if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key1val) != 1) {
28374 hvl_t buf1val = VLValToBuf(it0->second);
28375 AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val);
28376 InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val, buf1val);
28377 }
28378 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28379 ++count0;
28380
28381 }
28382 return buf;
28383}
28384hvl_t Hdf5Back::VLValToBuf(const std::list<std::pair<int, int>>& x) {
28385 hvl_t buf;
28386 buf.len=x.size();
28387 size_t item_size2elemfirst=sizeof(int);
28388 size_t item_size2elemsecond=sizeof(int);
28389 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
28390 size_t item_size1elem=total_item_size1elem;
28391 size_t total_item_size0=item_size1elem;
28392 size_t nbytes=total_item_size0*buf.len;
28393 buf.p=new char[nbytes];
28394 unsigned int count0=0;
28395 std::list<std::pair<int, int>>::const_iterator it0=x.begin();
28396 for(;it0!=x.end();++it0){
28397 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0).first), item_size2elemfirst);
28398 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst, &((*it0).second), item_size2elemsecond);
28399 ++count0;
28400
28401 }
28402 return buf;
28403}
28404hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::pair<std::string, std::vector<double>>>& x) {
28405 hvl_t buf;
28406 buf.len=x.size();
28407 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
28408 size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
28409 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
28410 size_t item_size1key=CYCLUS_SHA1_SIZE;
28411 size_t item_size1val=total_item_size1val;
28412 size_t total_item_size0=item_size1key+item_size1val;
28413 size_t nbytes=total_item_size0*buf.len;
28414 buf.p=new char[nbytes];
28415 unsigned int count0=0;
28416 std::map<std::string, std::pair<std::string, std::vector<double>>>::const_iterator it0=x.begin();
28417 for(;it0!=x.end();++it0){
28418 hasher_.Clear();
28419 hasher_.Update(it0->first);
28420 Digest key1key = hasher_.digest();
28421 hid_t keysds1key = VLDataset(VL_STRING, true);
28422 hid_t valsds1key = VLDataset(VL_STRING, false);
28423 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28424 AppendVLKey(keysds1key, VL_STRING, key1key);
28425 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28426 }
28427 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28428 hasher_.Clear();
28429 hasher_.Update(it0->second.first);
28430 Digest key2valfirst = hasher_.digest();
28431 hid_t keysds2valfirst = VLDataset(VL_STRING, true);
28432 hid_t valsds2valfirst = VLDataset(VL_STRING, false);
28433 if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
28434 AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
28435 InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
28436 }
28437 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key2valfirst.data(), item_size2valfirst);
28438 hasher_.Clear();
28439 hasher_.Update(it0->second.second);
28440 Digest key2valsecond = hasher_.digest();
28441 hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
28442 hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
28443 if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
28444 hvl_t buf2valsecond = VLValToBuf(it0->second.second);
28445 AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
28446 InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
28447 }
28448 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key+item_size2valfirst, key2valsecond.data(), item_size2valsecond);
28449 ++count0;
28450
28451 }
28452 return buf;
28453}
28454hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::map<std::string, int>>& x) {
28455 hvl_t buf;
28456 buf.len=x.size();
28457 size_t item_size1key=CYCLUS_SHA1_SIZE;
28458 size_t item_size1val=CYCLUS_SHA1_SIZE;
28459 size_t total_item_size0=item_size1key+item_size1val;
28460 size_t nbytes=total_item_size0*buf.len;
28461 buf.p=new char[nbytes];
28462 unsigned int count0=0;
28463 std::map<std::string, std::map<std::string, int>>::const_iterator it0=x.begin();
28464 for(;it0!=x.end();++it0){
28465 hasher_.Clear();
28466 hasher_.Update(it0->first);
28467 Digest key1key = hasher_.digest();
28468 hid_t keysds1key = VLDataset(VL_STRING, true);
28469 hid_t valsds1key = VLDataset(VL_STRING, false);
28470 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28471 AppendVLKey(keysds1key, VL_STRING, key1key);
28472 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28473 }
28474 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28475 hasher_.Clear();
28476 hasher_.Update(it0->second);
28477 Digest key1val = hasher_.digest();
28478 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_INT, true);
28479 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_INT, false);
28480 if (vlkeys_[VL_MAP_VL_STRING_INT].count(key1val) != 1) {
28481 hvl_t buf1val = VLValToBuf(it0->second);
28482 AppendVLKey(keysds1val, VL_MAP_VL_STRING_INT, key1val);
28483 InsertVLVal(valsds1val, VL_MAP_VL_STRING_INT, key1val, buf1val);
28484 }
28485 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28486 ++count0;
28487
28488 }
28489 return buf;
28490}
28491hvl_t Hdf5Back::VLValToBuf(const std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>& x) {
28492 hvl_t buf;
28493 buf.len=x.size();
28494 size_t item_size3elemfirstfirst=sizeof(double);
28495 size_t item_size3elemfirstsecond=sizeof(double);
28496 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
28497 size_t item_size2elemfirst=total_item_size2elemfirst;
28498 size_t item_size2elemsecond=CYCLUS_SHA1_SIZE;
28499 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
28500 size_t item_size1elem=total_item_size1elem;
28501 size_t total_item_size0=item_size1elem;
28502 size_t nbytes=total_item_size0*buf.len;
28503 buf.p=new char[nbytes];
28504 unsigned int count0=0;
28505 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::const_iterator it0=x.begin();
28506 for(;it0!=x.end();++it0){
28507 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0).first.first), item_size3elemfirstfirst);
28508 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size3elemfirstfirst, &((*it0).first.second), item_size3elemfirstsecond);
28509 hasher_.Clear();
28510 hasher_.Update((*it0).second);
28511 Digest key2elemsecond = hasher_.digest();
28512 hid_t keysds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
28513 hid_t valsds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
28514 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key2elemsecond) != 1) {
28515 hvl_t buf2elemsecond = VLValToBuf((*it0).second);
28516 AppendVLKey(keysds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond);
28517 InsertVLVal(valsds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond, buf2elemsecond);
28518 }
28519 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst, key2elemsecond.data(), item_size2elemsecond);
28520 ++count0;
28521
28522 }
28523 return buf;
28524}
28525hvl_t Hdf5Back::VLValToBuf(const std::vector<std::pair<int, std::pair<std::string, std::string>>>& x) {
28526 hvl_t buf;
28527 buf.len=x.size();
28528 size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
28529 size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
28530 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
28531 size_t item_size2elemfirst=sizeof(int);
28532 size_t item_size2elemsecond=total_item_size2elemsecond;
28533 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
28534 size_t item_size1elem=total_item_size1elem;
28535 size_t total_item_size0=item_size1elem;
28536 size_t nbytes=total_item_size0*buf.len;
28537 buf.p=new char[nbytes];
28538 unsigned int count0=0;
28539 std::vector<std::pair<int, std::pair<std::string, std::string>>>::const_iterator it0=x.begin();
28540 for(;it0!=x.end();++it0){
28541 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0).first), item_size2elemfirst);
28542 hasher_.Clear();
28543 hasher_.Update((*it0).second.first);
28544 Digest key3elemsecondfirst = hasher_.digest();
28545 hid_t keysds3elemsecondfirst = VLDataset(VL_STRING, true);
28546 hid_t valsds3elemsecondfirst = VLDataset(VL_STRING, false);
28547 if (vlkeys_[VL_STRING].count(key3elemsecondfirst) != 1) {
28548 AppendVLKey(keysds3elemsecondfirst, VL_STRING, key3elemsecondfirst);
28549 InsertVLVal(valsds3elemsecondfirst, VL_STRING, key3elemsecondfirst, (*it0).second.first);
28550 }
28551 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst, key3elemsecondfirst.data(), item_size3elemsecondfirst);
28552 hasher_.Clear();
28553 hasher_.Update((*it0).second.second);
28554 Digest key3elemsecondsecond = hasher_.digest();
28555 hid_t keysds3elemsecondsecond = VLDataset(VL_STRING, true);
28556 hid_t valsds3elemsecondsecond = VLDataset(VL_STRING, false);
28557 if (vlkeys_[VL_STRING].count(key3elemsecondsecond) != 1) {
28558 AppendVLKey(keysds3elemsecondsecond, VL_STRING, key3elemsecondsecond);
28559 InsertVLVal(valsds3elemsecondsecond, VL_STRING, key3elemsecondsecond, (*it0).second.second);
28560 }
28561 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst+item_size3elemsecondfirst, key3elemsecondsecond.data(), item_size3elemsecondsecond);
28562 ++count0;
28563
28564 }
28565 return buf;
28566}
28567hvl_t Hdf5Back::VLValToBuf(const std::map<std::pair<std::string, std::string>, int>& x) {
28568 hvl_t buf;
28569 buf.len=x.size();
28570 size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
28571 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
28572 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
28573 size_t item_size1key=total_item_size1key;
28574 size_t item_size1val=sizeof(int);
28575 size_t total_item_size0=item_size1key+item_size1val;
28576 size_t nbytes=total_item_size0*buf.len;
28577 buf.p=new char[nbytes];
28578 unsigned int count0=0;
28579 std::map<std::pair<std::string, std::string>, int>::const_iterator it0=x.begin();
28580 for(;it0!=x.end();++it0){
28581 hasher_.Clear();
28582 hasher_.Update(it0->first.first);
28583 Digest key2keyfirst = hasher_.digest();
28584 hid_t keysds2keyfirst = VLDataset(VL_STRING, true);
28585 hid_t valsds2keyfirst = VLDataset(VL_STRING, false);
28586 if (vlkeys_[VL_STRING].count(key2keyfirst) != 1) {
28587 AppendVLKey(keysds2keyfirst, VL_STRING, key2keyfirst);
28588 InsertVLVal(valsds2keyfirst, VL_STRING, key2keyfirst, it0->first.first);
28589 }
28590 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key2keyfirst.data(), item_size2keyfirst);
28591 hasher_.Clear();
28592 hasher_.Update(it0->first.second);
28593 Digest key2keysecond = hasher_.digest();
28594 hid_t keysds2keysecond = VLDataset(VL_STRING, true);
28595 hid_t valsds2keysecond = VLDataset(VL_STRING, false);
28596 if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
28597 AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
28598 InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
28599 }
28600 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2keyfirst, key2keysecond.data(), item_size2keysecond);
28601 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28602 ++count0;
28603
28604 }
28605 return buf;
28606}
28607hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::map<std::string, double>>& x) {
28608 hvl_t buf;
28609 buf.len=x.size();
28610 size_t item_size1key=CYCLUS_SHA1_SIZE;
28611 size_t item_size1val=CYCLUS_SHA1_SIZE;
28612 size_t total_item_size0=item_size1key+item_size1val;
28613 size_t nbytes=total_item_size0*buf.len;
28614 buf.p=new char[nbytes];
28615 unsigned int count0=0;
28616 std::map<std::string, std::map<std::string, double>>::const_iterator it0=x.begin();
28617 for(;it0!=x.end();++it0){
28618 hasher_.Clear();
28619 hasher_.Update(it0->first);
28620 Digest key1key = hasher_.digest();
28621 hid_t keysds1key = VLDataset(VL_STRING, true);
28622 hid_t valsds1key = VLDataset(VL_STRING, false);
28623 if (vlkeys_[VL_STRING].count(key1key) != 1) {
28624 AppendVLKey(keysds1key, VL_STRING, key1key);
28625 InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28626 }
28627 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.data(), item_size1key);
28628 hasher_.Clear();
28629 hasher_.Update(it0->second);
28630 Digest key1val = hasher_.digest();
28631 hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
28632 hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
28633 if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
28634 hvl_t buf1val = VLValToBuf(it0->second);
28635 AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
28636 InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
28637 }
28638 memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.data(), item_size1val);
28639 ++count0;
28640
28641 }
28642 return buf;
28643}
28644
28645
28646
28647template<>
28648std::vector<int> Hdf5Back::VLBufToVal<std::vector<int>>(const hvl_t& buf) {
28649 std::vector<int> x0;
28650 char* p=reinterpret_cast<char*>(buf.p);
28651 size_t item_size1elem=sizeof(int);
28652 size_t total_item_size0=item_size1elem;
28653 unsigned int count0=0;
28654 for(;count0<buf.len;++count0){
28655 int x1elem=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28656 x0.push_back(x1elem);
28657
28658 }
28659 return x0;
28660}
28661template<>
28662std::vector<float> Hdf5Back::VLBufToVal<std::vector<float>>(const hvl_t& buf) {
28663 std::vector<float> x0;
28664 char* p=reinterpret_cast<char*>(buf.p);
28665 size_t item_size1elem=sizeof(float);
28666 size_t total_item_size0=item_size1elem;
28667 unsigned int count0=0;
28668 for(;count0<buf.len;++count0){
28669 float x1elem=*reinterpret_cast<float*>(p+(total_item_size0*count0));
28670 x0.push_back(x1elem);
28671
28672 }
28673 return x0;
28674}
28675template<>
28676std::vector<double> Hdf5Back::VLBufToVal<std::vector<double>>(const hvl_t& buf) {
28677 std::vector<double> x0;
28678 char* p=reinterpret_cast<char*>(buf.p);
28679 size_t item_size1elem=sizeof(double);
28680 size_t total_item_size0=item_size1elem;
28681 unsigned int count0=0;
28682 for(;count0<buf.len;++count0){
28683 double x1elem=*reinterpret_cast<double*>(p+(total_item_size0*count0));
28684 x0.push_back(x1elem);
28685
28686 }
28687 return x0;
28688}
28689template<>
28690std::vector<std::string> Hdf5Back::VLBufToVal<std::vector<std::string>>(const hvl_t& buf) {
28691 std::vector<std::string> x0;
28692 char* p=reinterpret_cast<char*>(buf.p);
28693 size_t item_size1elem=CYCLUS_SHA1_SIZE;
28694 size_t total_item_size0=item_size1elem;
28695 unsigned int count0=0;
28696 for(;count0<buf.len;++count0){
28697 std::string x1elem=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
28698 x0.push_back(x1elem);
28699
28700 }
28701 return x0;
28702}
28703template<>
28704std::vector<cyclus::Blob> Hdf5Back::VLBufToVal<std::vector<cyclus::Blob>>(const hvl_t& buf) {
28705 std::vector<cyclus::Blob> x0;
28706 char* p=reinterpret_cast<char*>(buf.p);
28707 size_t item_size1elem=CYCLUS_SHA1_SIZE;
28708 size_t total_item_size0=item_size1elem;
28709 unsigned int count0=0;
28710 for(;count0<buf.len;++count0){
28711 cyclus::Blob x1elem=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0));
28712 x0.push_back(x1elem);
28713
28714 }
28715 return x0;
28716}
28717template<>
28718std::vector<boost::uuids::uuid> Hdf5Back::VLBufToVal<std::vector<boost::uuids::uuid>>(const hvl_t& buf) {
28719 std::vector<boost::uuids::uuid> x0;
28720 char* p=reinterpret_cast<char*>(buf.p);
28721 size_t item_size1elem=CYCLUS_UUID_SIZE;
28722 size_t total_item_size0=item_size1elem;
28723 unsigned int count0=0;
28724 for(;count0<buf.len;++count0){
28725 boost::uuids::uuid x1elem=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0));
28726 x0.push_back(x1elem);
28727
28728 }
28729 return x0;
28730}
28731template<>
28732std::set<int> Hdf5Back::VLBufToVal<std::set<int>>(const hvl_t& buf) {
28733 std::set<int> x0;
28734 char* p=reinterpret_cast<char*>(buf.p);
28735 size_t item_size1elem=sizeof(int);
28736 size_t total_item_size0=item_size1elem;
28737 unsigned int count0=0;
28738 for(;count0<buf.len;++count0){
28739 int x1elem=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28740 x0.insert(x1elem);
28741
28742 }
28743 return x0;
28744}
28745template<>
28746std::set<float> Hdf5Back::VLBufToVal<std::set<float>>(const hvl_t& buf) {
28747 std::set<float> x0;
28748 char* p=reinterpret_cast<char*>(buf.p);
28749 size_t item_size1elem=sizeof(float);
28750 size_t total_item_size0=item_size1elem;
28751 unsigned int count0=0;
28752 for(;count0<buf.len;++count0){
28753 float x1elem=*reinterpret_cast<float*>(p+(total_item_size0*count0));
28754 x0.insert(x1elem);
28755
28756 }
28757 return x0;
28758}
28759template<>
28760std::set<double> Hdf5Back::VLBufToVal<std::set<double>>(const hvl_t& buf) {
28761 std::set<double> x0;
28762 char* p=reinterpret_cast<char*>(buf.p);
28763 size_t item_size1elem=sizeof(double);
28764 size_t total_item_size0=item_size1elem;
28765 unsigned int count0=0;
28766 for(;count0<buf.len;++count0){
28767 double x1elem=*reinterpret_cast<double*>(p+(total_item_size0*count0));
28768 x0.insert(x1elem);
28769
28770 }
28771 return x0;
28772}
28773template<>
28774std::set<std::string> Hdf5Back::VLBufToVal<std::set<std::string>>(const hvl_t& buf) {
28775 std::set<std::string> x0;
28776 char* p=reinterpret_cast<char*>(buf.p);
28777 size_t item_size1elem=CYCLUS_SHA1_SIZE;
28778 size_t total_item_size0=item_size1elem;
28779 unsigned int count0=0;
28780 for(;count0<buf.len;++count0){
28781 std::string x1elem=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
28782 x0.insert(x1elem);
28783
28784 }
28785 return x0;
28786}
28787template<>
28788std::set<cyclus::Blob> Hdf5Back::VLBufToVal<std::set<cyclus::Blob>>(const hvl_t& buf) {
28789 std::set<cyclus::Blob> x0;
28790 char* p=reinterpret_cast<char*>(buf.p);
28791 size_t item_size1elem=CYCLUS_SHA1_SIZE;
28792 size_t total_item_size0=item_size1elem;
28793 unsigned int count0=0;
28794 for(;count0<buf.len;++count0){
28795 cyclus::Blob x1elem=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0));
28796 x0.insert(x1elem);
28797
28798 }
28799 return x0;
28800}
28801template<>
28802std::set<boost::uuids::uuid> Hdf5Back::VLBufToVal<std::set<boost::uuids::uuid>>(const hvl_t& buf) {
28803 std::set<boost::uuids::uuid> x0;
28804 char* p=reinterpret_cast<char*>(buf.p);
28805 size_t item_size1elem=CYCLUS_UUID_SIZE;
28806 size_t total_item_size0=item_size1elem;
28807 unsigned int count0=0;
28808 for(;count0<buf.len;++count0){
28809 boost::uuids::uuid x1elem=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0));
28810 x0.insert(x1elem);
28811
28812 }
28813 return x0;
28814}
28815template<>
28816std::list<bool> Hdf5Back::VLBufToVal<std::list<bool>>(const hvl_t& buf) {
28817 std::list<bool> x0;
28818 char* p=reinterpret_cast<char*>(buf.p);
28819 size_t item_size1elem=sizeof(char);
28820 size_t total_item_size0=item_size1elem;
28821 unsigned int count0=0;
28822 for(;count0<buf.len;++count0){
28823 bool x1elem=*reinterpret_cast<bool*>(p+(total_item_size0*count0));
28824 x0.push_back(x1elem);
28825
28826 }
28827 return x0;
28828}
28829template<>
28830std::list<int> Hdf5Back::VLBufToVal<std::list<int>>(const hvl_t& buf) {
28831 std::list<int> x0;
28832 char* p=reinterpret_cast<char*>(buf.p);
28833 size_t item_size1elem=sizeof(int);
28834 size_t total_item_size0=item_size1elem;
28835 unsigned int count0=0;
28836 for(;count0<buf.len;++count0){
28837 int x1elem=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28838 x0.push_back(x1elem);
28839
28840 }
28841 return x0;
28842}
28843template<>
28844std::list<float> Hdf5Back::VLBufToVal<std::list<float>>(const hvl_t& buf) {
28845 std::list<float> x0;
28846 char* p=reinterpret_cast<char*>(buf.p);
28847 size_t item_size1elem=sizeof(float);
28848 size_t total_item_size0=item_size1elem;
28849 unsigned int count0=0;
28850 for(;count0<buf.len;++count0){
28851 float x1elem=*reinterpret_cast<float*>(p+(total_item_size0*count0));
28852 x0.push_back(x1elem);
28853
28854 }
28855 return x0;
28856}
28857template<>
28858std::list<double> Hdf5Back::VLBufToVal<std::list<double>>(const hvl_t& buf) {
28859 std::list<double> x0;
28860 char* p=reinterpret_cast<char*>(buf.p);
28861 size_t item_size1elem=sizeof(double);
28862 size_t total_item_size0=item_size1elem;
28863 unsigned int count0=0;
28864 for(;count0<buf.len;++count0){
28865 double x1elem=*reinterpret_cast<double*>(p+(total_item_size0*count0));
28866 x0.push_back(x1elem);
28867
28868 }
28869 return x0;
28870}
28871template<>
28872std::list<std::string> Hdf5Back::VLBufToVal<std::list<std::string>>(const hvl_t& buf) {
28873 std::list<std::string> x0;
28874 char* p=reinterpret_cast<char*>(buf.p);
28875 size_t item_size1elem=CYCLUS_SHA1_SIZE;
28876 size_t total_item_size0=item_size1elem;
28877 unsigned int count0=0;
28878 for(;count0<buf.len;++count0){
28879 std::string x1elem=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
28880 x0.push_back(x1elem);
28881
28882 }
28883 return x0;
28884}
28885template<>
28886std::list<cyclus::Blob> Hdf5Back::VLBufToVal<std::list<cyclus::Blob>>(const hvl_t& buf) {
28887 std::list<cyclus::Blob> x0;
28888 char* p=reinterpret_cast<char*>(buf.p);
28889 size_t item_size1elem=CYCLUS_SHA1_SIZE;
28890 size_t total_item_size0=item_size1elem;
28891 unsigned int count0=0;
28892 for(;count0<buf.len;++count0){
28893 cyclus::Blob x1elem=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0));
28894 x0.push_back(x1elem);
28895
28896 }
28897 return x0;
28898}
28899template<>
28900std::list<boost::uuids::uuid> Hdf5Back::VLBufToVal<std::list<boost::uuids::uuid>>(const hvl_t& buf) {
28901 std::list<boost::uuids::uuid> x0;
28902 char* p=reinterpret_cast<char*>(buf.p);
28903 size_t item_size1elem=CYCLUS_UUID_SIZE;
28904 size_t total_item_size0=item_size1elem;
28905 unsigned int count0=0;
28906 for(;count0<buf.len;++count0){
28907 boost::uuids::uuid x1elem=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0));
28908 x0.push_back(x1elem);
28909
28910 }
28911 return x0;
28912}
28913template<>
28914std::map<int, bool> Hdf5Back::VLBufToVal<std::map<int, bool>>(const hvl_t& buf) {
28915 std::map<int, bool> x0;
28916 char* p=reinterpret_cast<char*>(buf.p);
28917 size_t item_size1key=sizeof(int);
28918 size_t item_size1val=sizeof(char);
28919 size_t total_item_size0=item_size1key+item_size1val;
28920 unsigned int count0=0;
28921 for(;count0<buf.len;++count0){
28922 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28923 bool x1val=*reinterpret_cast<bool*>(p+(total_item_size0*count0)+item_size1key);
28924 x0[x1key] = x1val;
28925
28926 }
28927 return x0;
28928}
28929template<>
28930std::map<int, int> Hdf5Back::VLBufToVal<std::map<int, int>>(const hvl_t& buf) {
28931 std::map<int, int> x0;
28932 char* p=reinterpret_cast<char*>(buf.p);
28933 size_t item_size1key=sizeof(int);
28934 size_t item_size1val=sizeof(int);
28935 size_t total_item_size0=item_size1key+item_size1val;
28936 unsigned int count0=0;
28937 for(;count0<buf.len;++count0){
28938 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28939 int x1val=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size1key);
28940 x0[x1key] = x1val;
28941
28942 }
28943 return x0;
28944}
28945template<>
28946std::map<int, float> Hdf5Back::VLBufToVal<std::map<int, float>>(const hvl_t& buf) {
28947 std::map<int, float> x0;
28948 char* p=reinterpret_cast<char*>(buf.p);
28949 size_t item_size1key=sizeof(int);
28950 size_t item_size1val=sizeof(float);
28951 size_t total_item_size0=item_size1key+item_size1val;
28952 unsigned int count0=0;
28953 for(;count0<buf.len;++count0){
28954 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28955 float x1val=*reinterpret_cast<float*>(p+(total_item_size0*count0)+item_size1key);
28956 x0[x1key] = x1val;
28957
28958 }
28959 return x0;
28960}
28961template<>
28962std::map<int, double> Hdf5Back::VLBufToVal<std::map<int, double>>(const hvl_t& buf) {
28963 std::map<int, double> x0;
28964 char* p=reinterpret_cast<char*>(buf.p);
28965 size_t item_size1key=sizeof(int);
28966 size_t item_size1val=sizeof(double);
28967 size_t total_item_size0=item_size1key+item_size1val;
28968 unsigned int count0=0;
28969 for(;count0<buf.len;++count0){
28970 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28971 double x1val=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
28972 x0[x1key] = x1val;
28973
28974 }
28975 return x0;
28976}
28977template<>
28978std::map<int, std::string> Hdf5Back::VLBufToVal<std::map<int, std::string>>(const hvl_t& buf) {
28979 std::map<int, std::string> x0;
28980 char* p=reinterpret_cast<char*>(buf.p);
28981 size_t item_size1key=sizeof(int);
28982 size_t item_size1val=CYCLUS_SHA1_SIZE;
28983 size_t total_item_size0=item_size1key+item_size1val;
28984 unsigned int count0=0;
28985 for(;count0<buf.len;++count0){
28986 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28987 std::string x1val=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size1key);
28988 x0[x1key] = x1val;
28989
28990 }
28991 return x0;
28992}
28993template<>
28994std::map<int, cyclus::Blob> Hdf5Back::VLBufToVal<std::map<int, cyclus::Blob>>(const hvl_t& buf) {
28995 std::map<int, cyclus::Blob> x0;
28996 char* p=reinterpret_cast<char*>(buf.p);
28997 size_t item_size1key=sizeof(int);
28998 size_t item_size1val=CYCLUS_SHA1_SIZE;
28999 size_t total_item_size0=item_size1key+item_size1val;
29000 unsigned int count0=0;
29001 for(;count0<buf.len;++count0){
29002 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29003 cyclus::Blob x1val=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0)+item_size1key);
29004 x0[x1key] = x1val;
29005
29006 }
29007 return x0;
29008}
29009template<>
29010std::map<int, boost::uuids::uuid> Hdf5Back::VLBufToVal<std::map<int, boost::uuids::uuid>>(const hvl_t& buf) {
29011 std::map<int, boost::uuids::uuid> x0;
29012 char* p=reinterpret_cast<char*>(buf.p);
29013 size_t item_size1key=sizeof(int);
29014 size_t item_size1val=CYCLUS_UUID_SIZE;
29015 size_t total_item_size0=item_size1key+item_size1val;
29016 unsigned int count0=0;
29017 for(;count0<buf.len;++count0){
29018 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29019 boost::uuids::uuid x1val=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0)+item_size1key);
29020 x0[x1key] = x1val;
29021
29022 }
29023 return x0;
29024}
29025template<>
29026std::map<std::string, bool> Hdf5Back::VLBufToVal<std::map<std::string, bool>>(const hvl_t& buf) {
29027 std::map<std::string, bool> x0;
29028 char* p=reinterpret_cast<char*>(buf.p);
29029 size_t item_size1key=CYCLUS_SHA1_SIZE;
29030 size_t item_size1val=sizeof(char);
29031 size_t total_item_size0=item_size1key+item_size1val;
29032 unsigned int count0=0;
29033 for(;count0<buf.len;++count0){
29034 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29035 bool x1val=*reinterpret_cast<bool*>(p+(total_item_size0*count0)+item_size1key);
29036 x0[x1key] = x1val;
29037
29038 }
29039 return x0;
29040}
29041template<>
29042std::map<std::string, int> Hdf5Back::VLBufToVal<std::map<std::string, int>>(const hvl_t& buf) {
29043 std::map<std::string, int> x0;
29044 char* p=reinterpret_cast<char*>(buf.p);
29045 size_t item_size1key=CYCLUS_SHA1_SIZE;
29046 size_t item_size1val=sizeof(int);
29047 size_t total_item_size0=item_size1key+item_size1val;
29048 unsigned int count0=0;
29049 for(;count0<buf.len;++count0){
29050 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29051 int x1val=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size1key);
29052 x0[x1key] = x1val;
29053
29054 }
29055 return x0;
29056}
29057template<>
29058std::map<std::string, float> Hdf5Back::VLBufToVal<std::map<std::string, float>>(const hvl_t& buf) {
29059 std::map<std::string, float> x0;
29060 char* p=reinterpret_cast<char*>(buf.p);
29061 size_t item_size1key=CYCLUS_SHA1_SIZE;
29062 size_t item_size1val=sizeof(float);
29063 size_t total_item_size0=item_size1key+item_size1val;
29064 unsigned int count0=0;
29065 for(;count0<buf.len;++count0){
29066 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29067 float x1val=*reinterpret_cast<float*>(p+(total_item_size0*count0)+item_size1key);
29068 x0[x1key] = x1val;
29069
29070 }
29071 return x0;
29072}
29073template<>
29074std::map<std::string, double> Hdf5Back::VLBufToVal<std::map<std::string, double>>(const hvl_t& buf) {
29075 std::map<std::string, double> x0;
29076 char* p=reinterpret_cast<char*>(buf.p);
29077 size_t item_size1key=CYCLUS_SHA1_SIZE;
29078 size_t item_size1val=sizeof(double);
29079 size_t total_item_size0=item_size1key+item_size1val;
29080 unsigned int count0=0;
29081 for(;count0<buf.len;++count0){
29082 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29083 double x1val=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
29084 x0[x1key] = x1val;
29085
29086 }
29087 return x0;
29088}
29089template<>
29090std::map<std::string, std::string> Hdf5Back::VLBufToVal<std::map<std::string, std::string>>(const hvl_t& buf) {
29091 std::map<std::string, std::string> x0;
29092 char* p=reinterpret_cast<char*>(buf.p);
29093 size_t item_size1key=CYCLUS_SHA1_SIZE;
29094 size_t item_size1val=CYCLUS_SHA1_SIZE;
29095 size_t total_item_size0=item_size1key+item_size1val;
29096 unsigned int count0=0;
29097 for(;count0<buf.len;++count0){
29098 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29099 std::string x1val=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size1key);
29100 x0[x1key] = x1val;
29101
29102 }
29103 return x0;
29104}
29105template<>
29106std::map<std::string, cyclus::Blob> Hdf5Back::VLBufToVal<std::map<std::string, cyclus::Blob>>(const hvl_t& buf) {
29107 std::map<std::string, cyclus::Blob> x0;
29108 char* p=reinterpret_cast<char*>(buf.p);
29109 size_t item_size1key=CYCLUS_SHA1_SIZE;
29110 size_t item_size1val=CYCLUS_SHA1_SIZE;
29111 size_t total_item_size0=item_size1key+item_size1val;
29112 unsigned int count0=0;
29113 for(;count0<buf.len;++count0){
29114 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29115 cyclus::Blob x1val=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0)+item_size1key);
29116 x0[x1key] = x1val;
29117
29118 }
29119 return x0;
29120}
29121template<>
29122std::map<std::string, boost::uuids::uuid> Hdf5Back::VLBufToVal<std::map<std::string, boost::uuids::uuid>>(const hvl_t& buf) {
29123 std::map<std::string, boost::uuids::uuid> x0;
29124 char* p=reinterpret_cast<char*>(buf.p);
29125 size_t item_size1key=CYCLUS_SHA1_SIZE;
29126 size_t item_size1val=CYCLUS_UUID_SIZE;
29127 size_t total_item_size0=item_size1key+item_size1val;
29128 unsigned int count0=0;
29129 for(;count0<buf.len;++count0){
29130 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29131 boost::uuids::uuid x1val=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0)+item_size1key);
29132 x0[x1key] = x1val;
29133
29134 }
29135 return x0;
29136}
29137template<>
29138std::map<std::pair<int, std::string>, double> Hdf5Back::VLBufToVal<std::map<std::pair<int, std::string>, double>>(const hvl_t& buf) {
29139 std::map<std::pair<int, std::string>, double> x0;
29140 char* p=reinterpret_cast<char*>(buf.p);
29141 size_t item_size2keyfirst=sizeof(int);
29142 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
29143 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
29144 size_t item_size1key=total_item_size1key;
29145 size_t item_size1val=sizeof(double);
29146 size_t total_item_size0=item_size1key+item_size1val;
29147 unsigned int count0=0;
29148 for(;count0<buf.len;++count0){
29149 std::pair<int, std::string> x1key;
29150 int x2keyfirst=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29151 std::string x2keysecond=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2keyfirst);
29152 x1key = std::make_pair(x2keyfirst,x2keysecond);
29153 double x1val=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
29154 x0[x1key] = x1val;
29155
29156 }
29157 return x0;
29158}
29159template<>
29160std::map<std::string, std::vector<double>> Hdf5Back::VLBufToVal<std::map<std::string, std::vector<double>>>(const hvl_t& buf) {
29161 std::map<std::string, std::vector<double>> x0;
29162 char* p=reinterpret_cast<char*>(buf.p);
29163 size_t item_size1key=CYCLUS_SHA1_SIZE;
29164 size_t item_size1val=CYCLUS_SHA1_SIZE;
29165 size_t total_item_size0=item_size1key+item_size1val;
29166 unsigned int count0=0;
29167 for(;count0<buf.len;++count0){
29168 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29169 std::vector<double> x1val=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29170 x0[x1key] = x1val;
29171
29172 }
29173 return x0;
29174}
29175template<>
29176std::map<std::string, std::map<int, double>> Hdf5Back::VLBufToVal<std::map<std::string, std::map<int, double>>>(const hvl_t& buf) {
29177 std::map<std::string, std::map<int, double>> x0;
29178 char* p=reinterpret_cast<char*>(buf.p);
29179 size_t item_size1key=CYCLUS_SHA1_SIZE;
29180 size_t item_size1val=CYCLUS_SHA1_SIZE;
29181 size_t total_item_size0=item_size1key+item_size1val;
29182 unsigned int count0=0;
29183 for(;count0<buf.len;++count0){
29184 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29185 std::map<int, double> x1val=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29186 x0[x1key] = x1val;
29187
29188 }
29189 return x0;
29190}
29191template<>
29192std::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) {
29193 std::map<std::string, std::pair<double, std::map<int, double>>> x0;
29194 char* p=reinterpret_cast<char*>(buf.p);
29195 size_t item_size2valfirst=sizeof(double);
29196 size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
29197 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
29198 size_t item_size1key=CYCLUS_SHA1_SIZE;
29199 size_t item_size1val=total_item_size1val;
29200 size_t total_item_size0=item_size1key+item_size1val;
29201 unsigned int count0=0;
29202 for(;count0<buf.len;++count0){
29203 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29204 std::pair<double, std::map<int, double>> x1val;
29205 double x2valfirst=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
29206 std::map<int, double> x2valsecond=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(p+(total_item_size0*count0)+item_size1key+item_size2valfirst);
29207 x1val = std::make_pair(x2valfirst,x2valsecond);
29208 x0[x1key] = x1val;
29209
29210 }
29211 return x0;
29212}
29213template<>
29214std::map<int, std::map<std::string, double>> Hdf5Back::VLBufToVal<std::map<int, std::map<std::string, double>>>(const hvl_t& buf) {
29215 std::map<int, std::map<std::string, double>> x0;
29216 char* p=reinterpret_cast<char*>(buf.p);
29217 size_t item_size1key=sizeof(int);
29218 size_t item_size1val=CYCLUS_SHA1_SIZE;
29219 size_t total_item_size0=item_size1key+item_size1val;
29220 unsigned int count0=0;
29221 for(;count0<buf.len;++count0){
29222 int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29223 std::map<std::string, double> x1val=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29224 x0[x1key] = x1val;
29225
29226 }
29227 return x0;
29228}
29229template<>
29230std::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) {
29231 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
29232 char* p=reinterpret_cast<char*>(buf.p);
29233 size_t item_size1key=CYCLUS_SHA1_SIZE;
29234 size_t item_size1val=CYCLUS_SHA1_SIZE;
29235 size_t total_item_size0=item_size1key+item_size1val;
29236 unsigned int count0=0;
29237 for(;count0<buf.len;++count0){
29238 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29239 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);
29240 x0[x1key] = x1val;
29241
29242 }
29243 return x0;
29244}
29245template<>
29246std::list<std::pair<int, int>> Hdf5Back::VLBufToVal<std::list<std::pair<int, int>>>(const hvl_t& buf) {
29247 std::list<std::pair<int, int>> x0;
29248 char* p=reinterpret_cast<char*>(buf.p);
29249 size_t item_size2elemfirst=sizeof(int);
29250 size_t item_size2elemsecond=sizeof(int);
29251 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
29252 size_t item_size1elem=total_item_size1elem;
29253 size_t total_item_size0=item_size1elem;
29254 unsigned int count0=0;
29255 for(;count0<buf.len;++count0){
29256 std::pair<int, int> x1elem;
29257 int x2elemfirst=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29258 int x2elemsecond=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size2elemfirst);
29259 x1elem = std::make_pair(x2elemfirst,x2elemsecond);
29260 x0.push_back(x1elem);
29261
29262 }
29263 return x0;
29264}
29265template<>
29266std::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) {
29267 std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
29268 char* p=reinterpret_cast<char*>(buf.p);
29269 size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
29270 size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
29271 size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
29272 size_t item_size1key=CYCLUS_SHA1_SIZE;
29273 size_t item_size1val=total_item_size1val;
29274 size_t total_item_size0=item_size1key+item_size1val;
29275 unsigned int count0=0;
29276 for(;count0<buf.len;++count0){
29277 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29278 std::pair<std::string, std::vector<double>> x1val;
29279 std::string x2valfirst=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size1key);
29280 std::vector<double> x2valsecond=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(p+(total_item_size0*count0)+item_size1key+item_size2valfirst);
29281 x1val = std::make_pair(x2valfirst,x2valsecond);
29282 x0[x1key] = x1val;
29283
29284 }
29285 return x0;
29286}
29287template<>
29288std::map<std::string, std::map<std::string, int>> Hdf5Back::VLBufToVal<std::map<std::string, std::map<std::string, int>>>(const hvl_t& buf) {
29289 std::map<std::string, std::map<std::string, int>> x0;
29290 char* p=reinterpret_cast<char*>(buf.p);
29291 size_t item_size1key=CYCLUS_SHA1_SIZE;
29292 size_t item_size1val=CYCLUS_SHA1_SIZE;
29293 size_t total_item_size0=item_size1key+item_size1val;
29294 unsigned int count0=0;
29295 for(;count0<buf.len;++count0){
29296 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29297 std::map<std::string, int> x1val=VLRead<std::map<std::string, int>,VL_MAP_VL_STRING_INT>(p+(total_item_size0*count0)+item_size1key);
29298 x0[x1key] = x1val;
29299
29300 }
29301 return x0;
29302}
29303template<>
29304std::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) {
29305 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
29306 char* p=reinterpret_cast<char*>(buf.p);
29307 size_t item_size3elemfirstfirst=sizeof(double);
29308 size_t item_size3elemfirstsecond=sizeof(double);
29309 size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
29310 size_t item_size2elemfirst=total_item_size2elemfirst;
29311 size_t item_size2elemsecond=CYCLUS_SHA1_SIZE;
29312 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
29313 size_t item_size1elem=total_item_size1elem;
29314 size_t total_item_size0=item_size1elem;
29315 unsigned int count0=0;
29316 for(;count0<buf.len;++count0){
29317 std::pair<std::pair<double, double>, std::map<std::string, double>> x1elem;
29318 std::pair<double, double> x2elemfirst;
29319 double x3elemfirstfirst=*reinterpret_cast<double*>(p+(total_item_size0*count0));
29320 double x3elemfirstsecond=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size3elemfirstfirst);
29321 x2elemfirst = std::make_pair(x3elemfirstfirst,x3elemfirstsecond);
29322 std::map<std::string, double> x2elemsecond=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(p+(total_item_size0*count0)+item_size2elemfirst);
29323 x1elem = std::make_pair(x2elemfirst,x2elemsecond);
29324 x0.push_back(x1elem);
29325
29326 }
29327 return x0;
29328}
29329template<>
29330std::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) {
29331 std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
29332 char* p=reinterpret_cast<char*>(buf.p);
29333 size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
29334 size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
29335 size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
29336 size_t item_size2elemfirst=sizeof(int);
29337 size_t item_size2elemsecond=total_item_size2elemsecond;
29338 size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
29339 size_t item_size1elem=total_item_size1elem;
29340 size_t total_item_size0=item_size1elem;
29341 unsigned int count0=0;
29342 for(;count0<buf.len;++count0){
29343 std::pair<int, std::pair<std::string, std::string>> x1elem;
29344 int x2elemfirst=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29345 std::pair<std::string, std::string> x2elemsecond;
29346 std::string x3elemsecondfirst=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2elemfirst);
29347 std::string x3elemsecondsecond=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2elemfirst+item_size3elemsecondfirst);
29348 x2elemsecond = std::make_pair(x3elemsecondfirst,x3elemsecondsecond);
29349 x1elem = std::make_pair(x2elemfirst,x2elemsecond);
29350 x0.push_back(x1elem);
29351
29352 }
29353 return x0;
29354}
29355template<>
29356std::map<std::pair<std::string, std::string>, int> Hdf5Back::VLBufToVal<std::map<std::pair<std::string, std::string>, int>>(const hvl_t& buf) {
29357 std::map<std::pair<std::string, std::string>, int> x0;
29358 char* p=reinterpret_cast<char*>(buf.p);
29359 size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
29360 size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
29361 size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
29362 size_t item_size1key=total_item_size1key;
29363 size_t item_size1val=sizeof(int);
29364 size_t total_item_size0=item_size1key+item_size1val;
29365 unsigned int count0=0;
29366 for(;count0<buf.len;++count0){
29367 std::pair<std::string, std::string> x1key;
29368 std::string x2keyfirst=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29369 std::string x2keysecond=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2keyfirst);
29370 x1key = std::make_pair(x2keyfirst,x2keysecond);
29371 int x1val=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size1key);
29372 x0[x1key] = x1val;
29373
29374 }
29375 return x0;
29376}
29377template<>
29378std::map<std::string, std::map<std::string, double>> Hdf5Back::VLBufToVal<std::map<std::string, std::map<std::string, double>>>(const hvl_t& buf) {
29379 std::map<std::string, std::map<std::string, double>> x0;
29380 char* p=reinterpret_cast<char*>(buf.p);
29381 size_t item_size1key=CYCLUS_SHA1_SIZE;
29382 size_t item_size1val=CYCLUS_SHA1_SIZE;
29383 size_t total_item_size0=item_size1key+item_size1val;
29384 unsigned int count0=0;
29385 for(;count0<buf.len;++count0){
29386 std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29387 std::map<std::string, double> x1val=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29388 x0[x1key] = x1val;
29389
29390 }
29391 return x0;
29392}
29393
29394
29395
29396} // namespace cyclus
boost::spirit::basic_hold_any
Definition any.hpp:194
boost::spirit::basic_hold_any::cast
T const & cast() const
Definition any.hpp:310
boost::spirit::basic_hold_any::castsmallvoid
const void * castsmallvoid() const
Definition any.hpp:320
cyclus::Blob
A type to represent variable-length array of bytes for dumping to a cyclus output database.
Definition blob.h:9
cyclus::Cond
Represents a condition used to filter rows returned by a query.
Definition query_backend.h:382
cyclus::Cond::field
std::string field
table column name
Definition query_backend.h:408
cyclus::Datum
Used to specify and send a collection of key-value pairs to the Recorder for recording.
Definition datum.h:15
cyclus::Datum::Shapes
std::vector< Shape > Shapes
Definition datum.h:22
cyclus::Datum::shapes
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
cyclus::Datum::Shape
std::vector< int > Shape
Definition datum.h:21
cyclus::Datum::Vals
std::vector< Entry > Vals
Definition datum.h:20
cyclus::Datum::title
std::string title()
Returns the datum's title as specified during the datum's creation.
Definition datum.cc:52
cyclus::Datum::vals
const Vals & vals()
Returns a vector of all field-value pairs that have been added to this datum.
Definition datum.cc:56
cyclus::Hdf5Back::Close
virtual void Close()
Closes and flushes the backend.
Definition hdf5_back.cc:41
cyclus::Hdf5Back::Flush
virtual void Flush()
Flushes all buffered data in the backend to its final format/location.
Definition hdf5_back.h:91
cyclus::Hdf5Back::ColumnTypes
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:15095
cyclus::Hdf5Back::Notify
virtual void Notify(DatumList data)
Used to pass a list of new/collected Datum objects.
Definition hdf5_back.cc:77
cyclus::Hdf5Back::Name
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
cyclus::Hdf5Back::Schema
virtual std::list< ColumnInfo > Schema(std::string table)
Return information about all columns of a table.
Definition hdf5_back.cc:15122
cyclus::Hdf5Back::Query
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
cyclus::Hdf5Back::~Hdf5Back
virtual ~Hdf5Back()
cleans up resources and closes the file.
Definition hdf5_back.cc:72
cyclus::Hdf5Back::Hdf5Back
Hdf5Back(std::string path)
Creates a new backend writing data to the specified file.
Definition hdf5_back.cc:11
cyclus::Hdf5Back::Tables
virtual std::set< std::string > Tables()
Return a set of all table names currently in the database.
Definition hdf5_back.cc:15154
cyclus::IOError
for failed reading/writing to files, network connections, etc..
Definition error.h:59
cyclus::QueryResult
Meta data and results of a query.
Definition query_backend.h:423
cyclus::QueryResult::rows
std::vector< QueryRow > rows
ordered results of a query
Definition query_backend.h:432
cyclus::QueryResult::types
std::vector< DbTypes > types
types of each field returned by a query.
Definition query_backend.h:429
cyclus::QueryResult::fields
std::vector< std::string > fields
names of each field returned by a query
Definition query_backend.h:426
cyclus::Sha1::Clear
void Clear()
Clears the current hash value to its default state.
Definition query_backend.h:635
cyclus::Sha1::Update
void Update(const std::string &s)
Updates the hash value in-place.
Definition query_backend.h:639
hdf5_back.h
cyclus
taken directly from OsiSolverInterface.cpp on 2/17/14 from https://projects.coin-or....
Definition agent.cc:14
cyclus::VLRead< std::string, VL_STRING >
std::string Hdf5Back::VLRead< std::string, VL_STRING >(const char *rawkey)
Definition hdf5_back.cc:100
cyclus::DatumList
std::vector< Datum * > DatumList
Definition rec_backend.h:12
cyclus::DbTypes
DbTypes
This is the primary list of all supported database types.
Definition query_backend.h:28
cyclus::VL_SET_DOUBLE
@ VL_SET_DOUBLE
Definition query_backend.h:63
cyclus::PAIR_VL_STRING_VL_STRING
@ PAIR_VL_STRING_VL_STRING
Definition query_backend.h:111
cyclus::VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE
@ VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:364
cyclus::VL_LIST_STRING
@ VL_LIST_STRING
Definition query_backend.h:82
cyclus::VL_MAP_VL_STRING_MAP_STRING_INT
@ VL_MAP_VL_STRING_MAP_STRING_INT
Definition query_backend.h:277
cyclus::MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
@ MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
Definition query_backend.h:194
cyclus::MAP_VL_STRING_INT
@ MAP_VL_STRING_INT
Definition query_backend.h:151
cyclus::VL_MAP_STRING_MAP_INT_DOUBLE
@ VL_MAP_STRING_MAP_INT_DOUBLE
Definition query_backend.h:184
cyclus::VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:231
cyclus::VL_MAP_STRING_VECTOR_DOUBLE
@ VL_MAP_STRING_VECTOR_DOUBLE
Definition query_backend.h:174
cyclus::VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
@ VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
Definition query_backend.h:197
cyclus::PAIR_STRING_VECTOR_DOUBLE
@ PAIR_STRING_VECTOR_DOUBLE
Definition query_backend.h:336
cyclus::PAIR_STRING_VL_VECTOR_DOUBLE
@ PAIR_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:338
cyclus::VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE
@ VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE
Definition query_backend.h:365
cyclus::VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE
@ VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE
Definition query_backend.h:286
cyclus::VL_MAP_STRING_FLOAT
@ VL_MAP_STRING_FLOAT
Definition query_backend.h:137
cyclus::MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
@ MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
Definition query_backend.h:252
cyclus::MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE
@ MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE
Definition query_backend.h:254
cyclus::MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:213
cyclus::MAP_VL_STRING_DOUBLE
@ MAP_VL_STRING_DOUBLE
Definition query_backend.h:155
cyclus::VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE
@ VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:289
cyclus::MAP_STRING_UUID
@ MAP_STRING_UUID
Definition query_backend.h:146
cyclus::MAP_VL_STRING_VL_STRING
@ MAP_VL_STRING_VL_STRING
Definition query_backend.h:159
cyclus::VL_MAP_VL_STRING_MAP_STRING_DOUBLE
@ VL_MAP_VL_STRING_MAP_STRING_DOUBLE
Definition query_backend.h:361
cyclus::VL_MAP_VL_STRING_VL_STRING
@ VL_MAP_VL_STRING_VL_STRING
Definition query_backend.h:160
cyclus::VL_MAP_STRING_VL_MAP_INT_DOUBLE
@ VL_MAP_STRING_VL_MAP_INT_DOUBLE
Definition query_backend.h:187
cyclus::MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:214
cyclus::VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:238
cyclus::MAP_STRING_FLOAT
@ MAP_STRING_FLOAT
Definition query_backend.h:136
cyclus::PAIR_INT_VL_STRING
@ PAIR_INT_VL_STRING
Definition query_backend.h:95
cyclus::PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE
@ PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE
Definition query_backend.h:307
cyclus::VL_MAP_STRING_VL_VECTOR_DOUBLE
@ VL_MAP_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:177
cyclus::VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
@ VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
Definition query_backend.h:262
cyclus::PAIR_VL_STRING_VECTOR_DOUBLE
@ PAIR_VL_STRING_VECTOR_DOUBLE
Definition query_backend.h:337
cyclus::VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:328
cyclus::PAIR_INT_FLOAT
@ PAIR_INT_FLOAT
Definition query_backend.h:92
cyclus::MAP_STRING_STRING
@ MAP_STRING_STRING
Definition query_backend.h:140
cyclus::VL_MAP_INT_BLOB
@ VL_MAP_INT_BLOB
Definition query_backend.h:128
cyclus::PAIR_DOUBLE_VL_MAP_INT_DOUBLE
@ PAIR_DOUBLE_VL_MAP_INT_DOUBLE
Definition query_backend.h:324
cyclus::MAP_STRING_MAP_STRING_DOUBLE
@ MAP_STRING_MAP_STRING_DOUBLE
Definition query_backend.h:352
cyclus::PAIR_STRING_STRING
@ PAIR_STRING_STRING
Definition query_backend.h:102
cyclus::VL_LIST_PAIR_INT_INT
@ VL_LIST_PAIR_INT_INT
Definition query_backend.h:247
cyclus::VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
@ VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
Definition query_backend.h:260
cyclus::VL_MAP_STRING_MAP_STRING_INT
@ VL_MAP_STRING_MAP_STRING_INT
Definition query_backend.h:276
cyclus::MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:215
cyclus::MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:226
cyclus::MAP_VL_STRING_BLOB
@ MAP_VL_STRING_BLOB
Definition query_backend.h:161
cyclus::VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE
@ VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE
Definition query_backend.h:292
cyclus::MAP_INT_VL_MAP_STRING_DOUBLE
@ MAP_INT_VL_MAP_STRING_DOUBLE
Definition query_backend.h:206
cyclus::VL_MAP_STRING_STRING
@ VL_MAP_STRING_STRING
Definition query_backend.h:141
cyclus::MAP_INT_MAP_STRING_DOUBLE
@ MAP_INT_MAP_STRING_DOUBLE
Definition query_backend.h:202
cyclus::MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
@ MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:257
cyclus::PAIR_INT_STRING
@ PAIR_INT_STRING
Definition query_backend.h:94
cyclus::MAP_VL_STRING_STRING
@ MAP_VL_STRING_STRING
Definition query_backend.h:157
cyclus::VL_MAP_VL_STRING_VECTOR_DOUBLE
@ VL_MAP_VL_STRING_VECTOR_DOUBLE
Definition query_backend.h:178
cyclus::MAP_VL_STRING_UUID
@ MAP_VL_STRING_UUID
Definition query_backend.h:163
cyclus::MAP_STRING_BLOB
@ MAP_STRING_BLOB
Definition query_backend.h:144
cyclus::MAP_STRING_VECTOR_DOUBLE
@ MAP_STRING_VECTOR_DOUBLE
Definition query_backend.h:172
cyclus::PAIR_INT_PAIR_STRING_STRING
@ PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:296
cyclus::MAP_VL_STRING_FLOAT
@ MAP_VL_STRING_FLOAT
Definition query_backend.h:153
cyclus::MAP_PAIR_STRING_VL_STRING_INT
@ MAP_PAIR_STRING_VL_STRING_INT
Definition query_backend.h:343
cyclus::VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE
@ VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE
Definition query_backend.h:288
cyclus::VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT
@ VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT
Definition query_backend.h:283
cyclus::VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:236
cyclus::VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:334
cyclus::VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
@ VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:261
cyclus::VECTOR_PAIR_INT_PAIR_STRING_STRING
@ VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:327
cyclus::MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
@ MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
Definition query_backend.h:198
cyclus::MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
@ MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
Definition query_backend.h:195
cyclus::VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:237
cyclus::MAP_STRING_VL_MAP_STRING_INT
@ MAP_STRING_VL_MAP_STRING_INT
Definition query_backend.h:270
cyclus::VL_MAP_INT_MAP_VL_STRING_DOUBLE
@ VL_MAP_INT_MAP_VL_STRING_DOUBLE
Definition query_backend.h:205
cyclus::VL_VECTOR_FLOAT
@ VL_VECTOR_FLOAT
Definition query_backend.h:44
cyclus::MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:212
cyclus::LIST_VL_STRING
@ LIST_VL_STRING
Definition query_backend.h:83
cyclus::PAIR_VL_STRING_BOOL
@ PAIR_VL_STRING_BOOL
Definition query_backend.h:106
cyclus::PAIR_VL_STRING_FLOAT
@ PAIR_VL_STRING_FLOAT
Definition query_backend.h:108
cyclus::MAP_VL_STRING_VECTOR_DOUBLE
@ MAP_VL_STRING_VECTOR_DOUBLE
Definition query_backend.h:175
cyclus::VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE
@ VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE
Definition query_backend.h:259
cyclus::MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:222
cyclus::MAP_VL_STRING_MAP_VL_STRING_INT
@ MAP_VL_STRING_MAP_VL_STRING_INT
Definition query_backend.h:274
cyclus::VL_MAP_STRING_INT
@ VL_MAP_STRING_INT
Definition query_backend.h:135
cyclus::VL_MAP_STRING_VL_MAP_STRING_INT
@ VL_MAP_STRING_VL_MAP_STRING_INT
Definition query_backend.h:278
cyclus::VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:234
cyclus::VL_LIST_FLOAT
@ VL_LIST_FLOAT
Definition query_backend.h:78
cyclus::VL_MAP_PAIR_STRING_VL_STRING_INT
@ VL_MAP_PAIR_STRING_VL_STRING_INT
Definition query_backend.h:347
cyclus::VL_MAP_STRING_MAP_VL_STRING_INT
@ VL_MAP_STRING_MAP_VL_STRING_INT
Definition query_backend.h:279
cyclus::VL_MAP_STRING_MAP_VL_STRING_DOUBLE
@ VL_MAP_STRING_MAP_VL_STRING_DOUBLE
Definition query_backend.h:363
cyclus::VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:241
cyclus::VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:232
cyclus::VL_VECTOR_BLOB
@ VL_VECTOR_BLOB
Definition query_backend.h:52
cyclus::MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:223
cyclus::VL_SET_STRING
@ VL_SET_STRING
Definition query_backend.h:65
cyclus::VL_MAP_INT_FLOAT
@ VL_MAP_INT_FLOAT
Definition query_backend.h:120
cyclus::VL_MAP_PAIR_VL_STRING_STRING_INT
@ VL_MAP_PAIR_VL_STRING_STRING_INT
Definition query_backend.h:348
cyclus::VL_MAP_STRING_MAP_STRING_DOUBLE
@ VL_MAP_STRING_MAP_STRING_DOUBLE
Definition query_backend.h:360
cyclus::SET_VL_STRING
@ SET_VL_STRING
Definition query_backend.h:66
cyclus::PAIR_VL_STRING_BLOB
@ PAIR_VL_STRING_BLOB
Definition query_backend.h:112
cyclus::VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE
@ VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE
Definition query_backend.h:287
cyclus::VL_MAP_INT_BOOL
@ VL_MAP_INT_BOOL
Definition query_backend.h:116
cyclus::MAP_STRING_MAP_STRING_INT
@ MAP_STRING_MAP_STRING_INT
Definition query_backend.h:268
cyclus::VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE
@ VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:209
cyclus::VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:332
cyclus::MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE
@ MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:359
cyclus::MAP_PAIR_INT_STRING_DOUBLE
@ MAP_PAIR_INT_STRING_DOUBLE
Definition query_backend.h:166
cyclus::PAIR_STRING_FLOAT
@ PAIR_STRING_FLOAT
Definition query_backend.h:100
cyclus::PAIR_STRING_DOUBLE
@ PAIR_STRING_DOUBLE
Definition query_backend.h:101
cyclus::PAIR_VL_STRING_DOUBLE
@ PAIR_VL_STRING_DOUBLE
Definition query_backend.h:109
cyclus::VL_MAP_INT_MAP_STRING_DOUBLE
@ VL_MAP_INT_MAP_STRING_DOUBLE
Definition query_backend.h:204
cyclus::VL_VECTOR_DOUBLE
@ VL_VECTOR_DOUBLE
Definition query_backend.h:46
cyclus::VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE
@ VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE
Definition query_backend.h:290
cyclus::PAIR_VL_STRING_INT
@ PAIR_VL_STRING_INT
Definition query_backend.h:107
cyclus::PAIR_INT_PAIR_VL_STRING_VL_STRING
@ PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:299
cyclus::MAP_STRING_VL_MAP_VL_STRING_INT
@ MAP_STRING_VL_MAP_VL_STRING_INT
Definition query_backend.h:271
cyclus::LIST_PAIR_INT_INT
@ LIST_PAIR_INT_INT
Definition query_backend.h:246
cyclus::VL_MAP_VL_STRING_BLOB
@ VL_MAP_VL_STRING_BLOB
Definition query_backend.h:162
cyclus::VL_MAP_VL_STRING_UUID
@ VL_MAP_VL_STRING_UUID
Definition query_backend.h:164
cyclus::MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
@ MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:256
cyclus::PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE
@ PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:308
cyclus::MAP_VL_STRING_BOOL
@ MAP_VL_STRING_BOOL
Definition query_backend.h:149
cyclus::VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
@ VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:265
cyclus::VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
@ VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
Definition query_backend.h:193
cyclus::MAP_VL_STRING_VL_MAP_VL_STRING_INT
@ MAP_VL_STRING_VL_MAP_VL_STRING_INT
Definition query_backend.h:275
cyclus::MAP_VL_STRING_VL_MAP_STRING_INT
@ MAP_VL_STRING_VL_MAP_STRING_INT
Definition query_backend.h:273
cyclus::MAP_STRING_MAP_VL_STRING_DOUBLE
@ MAP_STRING_MAP_VL_STRING_DOUBLE
Definition query_backend.h:353
cyclus::VL_MAP_STRING_VL_STRING
@ VL_MAP_STRING_VL_STRING
Definition query_backend.h:143
cyclus::VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:235
cyclus::PAIR_DOUBLE_DOUBLE
@ PAIR_DOUBLE_DOUBLE
Definition query_backend.h:302
cyclus::PAIR_INT_BOOL
@ PAIR_INT_BOOL
Definition query_backend.h:90
cyclus::MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:225
cyclus::VL_MAP_INT_DOUBLE
@ VL_MAP_INT_DOUBLE
Definition query_backend.h:122
cyclus::MAP_STRING_DOUBLE
@ MAP_STRING_DOUBLE
Definition query_backend.h:138
cyclus::PAIR_VL_STRING_UUID
@ PAIR_VL_STRING_UUID
Definition query_backend.h:113
cyclus::VL_MAP_INT_STRING
@ VL_MAP_INT_STRING
Definition query_backend.h:124
cyclus::PAIR_STRING_BOOL
@ PAIR_STRING_BOOL
Definition query_backend.h:98
cyclus::VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:329
cyclus::VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:228
cyclus::VL_MAP_STRING_BLOB
@ VL_MAP_STRING_BLOB
Definition query_backend.h:145
cyclus::VL_MAP_INT_UUID
@ VL_MAP_INT_UUID
Definition query_backend.h:130
cyclus::MAP_PAIR_STRING_STRING_INT
@ MAP_PAIR_STRING_STRING_INT
Definition query_backend.h:342
cyclus::VL_VECTOR_UUID
@ VL_VECTOR_UUID
Definition query_backend.h:54
cyclus::MAP_PAIR_VL_STRING_VL_STRING_INT
@ MAP_PAIR_VL_STRING_VL_STRING_INT
Definition query_backend.h:345
cyclus::MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:220
cyclus::MAP_VL_STRING_MAP_VL_STRING_DOUBLE
@ MAP_VL_STRING_MAP_VL_STRING_DOUBLE
Definition query_backend.h:358
cyclus::MAP_STRING_VL_MAP_INT_DOUBLE
@ MAP_STRING_VL_MAP_INT_DOUBLE
Definition query_backend.h:183
cyclus::MAP_STRING_BOOL
@ MAP_STRING_BOOL
Definition query_backend.h:132
cyclus::PAIR_INT_PAIR_VL_STRING_STRING
@ PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:297
cyclus::VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:239
cyclus::VL_MAP_INT_VL_STRING
@ VL_MAP_INT_VL_STRING
Definition query_backend.h:126
cyclus::VL_LIST_VL_STRING
@ VL_LIST_VL_STRING
Definition query_backend.h:84
cyclus::VL_MAP_STRING_VL_MAP_STRING_DOUBLE
@ VL_MAP_STRING_VL_MAP_STRING_DOUBLE
Definition query_backend.h:362
cyclus::PAIR_STRING_BLOB
@ PAIR_STRING_BLOB
Definition query_backend.h:104
cyclus::MAP_VL_STRING_VL_MAP_STRING_DOUBLE
@ MAP_VL_STRING_VL_MAP_STRING_DOUBLE
Definition query_backend.h:357
cyclus::VL_MAP_PAIR_INT_STRING_DOUBLE
@ VL_MAP_PAIR_INT_STRING_DOUBLE
Definition query_backend.h:167
cyclus::VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
@ VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:264
cyclus::VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:240
cyclus::MAP_INT_MAP_VL_STRING_DOUBLE
@ MAP_INT_MAP_VL_STRING_DOUBLE
Definition query_backend.h:203
cyclus::VL_VECTOR_VL_STRING
@ VL_VECTOR_VL_STRING
Definition query_backend.h:50
cyclus::PAIR_STRING_VL_STRING
@ PAIR_STRING_VL_STRING
Definition query_backend.h:103
cyclus::PAIR_INT_DOUBLE
@ PAIR_INT_DOUBLE
Definition query_backend.h:93
cyclus::VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:230
cyclus::VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE
@ VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE
Definition query_backend.h:258
cyclus::MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
@ MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
Definition query_backend.h:192
cyclus::MAP_VL_STRING_MAP_STRING_DOUBLE
@ MAP_VL_STRING_MAP_STRING_DOUBLE
Definition query_backend.h:356
cyclus::MAP_VL_STRING_VL_MAP_INT_DOUBLE
@ MAP_VL_STRING_VL_MAP_INT_DOUBLE
Definition query_backend.h:186
cyclus::MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
@ MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE
Definition query_backend.h:255
cyclus::MAP_STRING_PAIR_STRING_VECTOR_DOUBLE
@ MAP_STRING_PAIR_STRING_VECTOR_DOUBLE
Definition query_backend.h:250
cyclus::VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
@ VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:263
cyclus::MAP_STRING_VL_MAP_VL_STRING_DOUBLE
@ MAP_STRING_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:355
cyclus::VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:243
cyclus::VL_MAP_STRING_BOOL
@ VL_MAP_STRING_BOOL
Definition query_backend.h:133
cyclus::MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
@ MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:251
cyclus::PAIR_STRING_UUID
@ PAIR_STRING_UUID
Definition query_backend.h:105
cyclus::MAP_PAIR_INT_VL_STRING_DOUBLE
@ MAP_PAIR_INT_VL_STRING_DOUBLE
Definition query_backend.h:168
cyclus::VL_MAP_STRING_UUID
@ VL_MAP_STRING_UUID
Definition query_backend.h:147
cyclus::MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
@ MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:253
cyclus::MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:218
cyclus::MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:227
cyclus::VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:331
cyclus::PAIR_INT_BLOB
@ PAIR_INT_BLOB
Definition query_backend.h:96
cyclus::VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE
@ VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:293
cyclus::VL_MAP_VL_STRING_STRING
@ VL_MAP_VL_STRING_STRING
Definition query_backend.h:158
cyclus::VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:330
cyclus::VL_MAP_VL_STRING_INT
@ VL_MAP_VL_STRING_INT
Definition query_backend.h:152
cyclus::VECTOR_STRING
@ VECTOR_STRING
Definition query_backend.h:47
cyclus::VL_VECTOR_INT
@ VL_VECTOR_INT
Definition query_backend.h:42
cyclus::VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
@ VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE
Definition query_backend.h:196
cyclus::VL_MAP_VL_STRING_MAP_VL_STRING_INT
@ VL_MAP_VL_STRING_MAP_VL_STRING_INT
Definition query_backend.h:281
cyclus::VL_MAP_STRING_DOUBLE
@ VL_MAP_STRING_DOUBLE
Definition query_backend.h:139
cyclus::VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:233
cyclus::PAIR_VL_STRING_STRING
@ PAIR_VL_STRING_STRING
Definition query_backend.h:110
cyclus::VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE
@ VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE
Definition query_backend.h:366
cyclus::VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
@ VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE
Definition query_backend.h:199
cyclus::VECTOR_DOUBLE
@ VECTOR_DOUBLE
Definition query_backend.h:45
cyclus::MAP_STRING_MAP_INT_DOUBLE
@ MAP_STRING_MAP_INT_DOUBLE
Definition query_backend.h:182
cyclus::MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
@ MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING
Definition query_backend.h:219
cyclus::VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE
@ VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE
Definition query_backend.h:189
cyclus::VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
@ VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING
Definition query_backend.h:242
cyclus::VL_MAP_INT_VL_MAP_STRING_DOUBLE
@ VL_MAP_INT_VL_MAP_STRING_DOUBLE
Definition query_backend.h:208
cyclus::VL_MAP_STRING_VL_MAP_VL_STRING_INT
@ VL_MAP_STRING_VL_MAP_VL_STRING_INT
Definition query_backend.h:280
cyclus::VL_MAP_PAIR_VL_STRING_VL_STRING_INT
@ VL_MAP_PAIR_VL_STRING_VL_STRING_INT
Definition query_backend.h:349
cyclus::VL_MAP_VL_STRING_DOUBLE
@ VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:156
cyclus::VL_MAP_PAIR_INT_VL_STRING_DOUBLE
@ VL_MAP_PAIR_INT_VL_STRING_DOUBLE
Definition query_backend.h:169
cyclus::VL_MAP_VL_STRING_VL_VECTOR_DOUBLE
@ VL_MAP_VL_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:179
cyclus::MAP_VL_STRING_MAP_STRING_INT
@ MAP_VL_STRING_MAP_STRING_INT
Definition query_backend.h:272
cyclus::MAP_INT_VL_MAP_VL_STRING_DOUBLE
@ MAP_INT_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:207
cyclus::VL_LIST_DOUBLE
@ VL_LIST_DOUBLE
Definition query_backend.h:80
cyclus::MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:221
cyclus::VL_MAP_VL_STRING_FLOAT
@ VL_MAP_VL_STRING_FLOAT
Definition query_backend.h:154
cyclus::VECTOR_VL_STRING
@ VECTOR_VL_STRING
Definition query_backend.h:49
cyclus::VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE
@ VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE
Definition query_backend.h:291
cyclus::MAP_STRING_VL_MAP_STRING_DOUBLE
@ MAP_STRING_VL_MAP_STRING_DOUBLE
Definition query_backend.h:354
cyclus::VL_MAP_VL_STRING_BOOL
@ VL_MAP_VL_STRING_BOOL
Definition query_backend.h:150
cyclus::MAP_VL_STRING_VL_VECTOR_DOUBLE
@ MAP_VL_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:176
cyclus::VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:333
cyclus::MAP_PAIR_VL_STRING_STRING_INT
@ MAP_PAIR_VL_STRING_STRING_INT
Definition query_backend.h:344
cyclus::PAIR_INT_PAIR_STRING_VL_STRING
@ PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:298
cyclus::VL_MAP_VL_STRING_VL_MAP_STRING_INT
@ VL_MAP_VL_STRING_VL_MAP_STRING_INT
Definition query_backend.h:282
cyclus::MAP_STRING_VL_VECTOR_DOUBLE
@ MAP_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:173
cyclus::PAIR_DOUBLE_MAP_INT_DOUBLE
@ PAIR_DOUBLE_MAP_INT_DOUBLE
Definition query_backend.h:323
cyclus::MAP_STRING_MAP_VL_STRING_INT
@ MAP_STRING_MAP_VL_STRING_INT
Definition query_backend.h:269
cyclus::VL_MAP_VL_STRING_MAP_INT_DOUBLE
@ VL_MAP_VL_STRING_MAP_INT_DOUBLE
Definition query_backend.h:188
cyclus::VL_SET_VL_STRING
@ VL_SET_VL_STRING
Definition query_backend.h:67
cyclus::VL_VECTOR_STRING
@ VL_VECTOR_STRING
Definition query_backend.h:48
cyclus::MAP_STRING_VL_STRING
@ MAP_STRING_VL_STRING
Definition query_backend.h:142
cyclus::MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:217
cyclus::PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE
@ PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE
Definition query_backend.h:306
cyclus::VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE
@ VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE
Definition query_backend.h:367
cyclus::PAIR_INT_UUID
@ PAIR_INT_UUID
Definition query_backend.h:97
cyclus::VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
@ VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING
Definition query_backend.h:229
cyclus::MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:216
cyclus::MAP_VL_STRING_MAP_INT_DOUBLE
@ MAP_VL_STRING_MAP_INT_DOUBLE
Definition query_backend.h:185
cyclus::MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
@ MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING
Definition query_backend.h:224
cyclus::PAIR_STRING_INT
@ PAIR_STRING_INT
Definition query_backend.h:99
cyclus::PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE
@ PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE
Definition query_backend.h:305
cyclus::VL_MAP_PAIR_STRING_STRING_INT
@ VL_MAP_PAIR_STRING_STRING_INT
Definition query_backend.h:346
cyclus::MAP_INT_VL_STRING
@ MAP_INT_VL_STRING
Definition query_backend.h:125
cyclus::PAIR_VL_STRING_VL_VECTOR_DOUBLE
@ PAIR_VL_STRING_VL_VECTOR_DOUBLE
Definition query_backend.h:339
cyclus::QueryRow
std::vector< boost::spirit::hold_any > QueryRow
Definition query_backend.h:420
cyclus::Digest
std::array< CYCLUS_SHA1_ELEM_TYPE, CYCLUS_SHA1_NINT > Digest
The digest type for SHA1s.
Definition query_backend.h:628
cyclus::CmpConds
bool CmpConds(T *x, std::vector< Cond * > *conds)
Compares all condiontions for a value.
Definition query_backend.h:619
hdf5_back_gen.memcpy
memcpy(dest, src, size)
Definition hdf5_back_gen.py:1800
hdf5_back_gen.memset
memset(dest, src, size)
Definition hdf5_back_gen.py:1806
pyne::nucname::name
std::string name(int nuc)
Definition pyne.cc:2940
pyne::rxname::offset
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
CYCLUS_UUID_SIZE
#define CYCLUS_UUID_SIZE
Definition query_backend.h:19
CYCLUS_SHA1_SIZE
#define CYCLUS_SHA1_SIZE
Definition query_backend.h:18
CYCLUS_SHA1_NINT
#define CYCLUS_SHA1_NINT
Definition query_backend.h:16
cyclus::ColumnInfo
Represents column information.
Definition query_backend.h:481