Warning, /include/Geant4/toolx/hdf5/T_tools is written in an unsupported language. File is not indexed.
0001 // Copyright (C) 2010, Guy Barrand. All rights reserved.
0002 // See the file tools.license for terms.
0003
0004 #ifndef toolx_hdf5_T_tools
0005 #define toolx_hdf5_T_tools
0006
0007 #include "hdf5_h"
0008
0009 #include <tools/typedefs>
0010 #include <tools/forit>
0011 #include <tools/num2s>
0012
0013 namespace toolx {
0014 namespace hdf5 {
0015
0016 inline hid_t to_T_file_type(char) {return H5T_STD_I8LE;} //H5T_STD_I8XX()
0017 inline hid_t to_T_file_type(short) {return H5T_STD_I16LE;} //HST_STD_I16XX()
0018 inline hid_t to_T_file_type(int) {return H5T_STD_I32LE;} //H5T_STD_I32XX()
0019 inline hid_t to_T_file_type(tools::int64) {return H5T_STD_I64LE;} //H5T_STD_I64XX()
0020
0021 inline hid_t to_T_file_type(float) {return H5T_IEEE_F32LE;} //H5T_IEEE_F32XX()
0022 inline hid_t to_T_file_type(double) {return H5T_IEEE_F64LE;} //H5T_IEEE_F64XX()
0023
0024 inline hid_t to_T_file_type(unsigned char) {return H5T_STD_U8LE;}
0025 inline hid_t to_T_file_type(unsigned short) {return H5T_STD_U16LE;}
0026 inline hid_t to_T_file_type(unsigned int) {return H5T_STD_U32LE;}
0027 inline hid_t to_T_file_type(tools::uint64) {return H5T_STD_U64LE;}
0028
0029 inline hid_t to_T_mem_type(char) {return H5T_NATIVE_CHAR;}
0030 inline hid_t to_T_mem_type(short) {return H5T_NATIVE_SHORT;}
0031 inline hid_t to_T_mem_type(int) {return H5T_NATIVE_INT;}
0032 inline hid_t to_T_mem_type(tools::int64) {return H5T_NATIVE_INT64;}
0033
0034 inline hid_t to_T_mem_type(float) {return H5T_NATIVE_FLOAT;}
0035 inline hid_t to_T_mem_type(double) {return H5T_NATIVE_DOUBLE;}
0036
0037 inline hid_t to_T_mem_type(unsigned char) {return H5T_NATIVE_UCHAR;}
0038 inline hid_t to_T_mem_type(unsigned short) {return H5T_NATIVE_USHORT;}
0039 inline hid_t to_T_mem_type(unsigned int) {return H5T_NATIVE_UINT;}
0040 inline hid_t to_T_mem_type(tools::uint64) {return H5T_NATIVE_UINT64;}
0041
0042 template <class T>
0043 inline bool write_array(hid_t a_loc,const std::string& a_name,
0044 hid_t a_file_type,hid_t a_mem_type,
0045 unsigned int a_chunked,unsigned int a_compress,
0046 unsigned int a_size,const T a_array[]) {
0047 if(!a_size) return false;
0048
0049 hid_t cpt = -1;
0050 if(a_compress || a_chunked) {
0051 cpt = ::H5Pcreate(H5P_DATASET_CREATE);
0052 if(cpt<0) return false;
0053 if(a_chunked) {
0054 if(H5Pset_layout(cpt,H5D_CHUNKED)<0) {
0055 ::H5Pclose(cpt);
0056 return false;
0057 }
0058 hsize_t cdims[1];
0059 cdims[0] = a_chunked;
0060 if(H5Pset_chunk(cpt,1,cdims)<0) {
0061 ::H5Pclose(cpt);
0062 return false;
0063 }
0064 } else {
0065 if(H5Pset_layout(cpt,H5D_COMPACT)<0) {
0066 ::H5Pclose(cpt);
0067 return false;
0068 }
0069 }
0070 if(a_compress) {
0071 if(H5Pset_deflate(cpt,a_compress>9?9:a_compress)<0) {
0072 ::H5Pclose(cpt);
0073 return false;
0074 }
0075 }
0076 } else {
0077 cpt = H5P_DEFAULT;
0078 }
0079
0080 hid_t dataset = -1;
0081
0082 {hsize_t dims[1];
0083 dims[0] = a_size;
0084 hid_t file_space = -1;
0085 if(a_chunked) {
0086 hsize_t mx_dims[1];
0087 mx_dims[0] = H5S_UNLIMITED; //extendable.
0088 file_space = ::H5Screate_simple(1,dims,mx_dims);
0089 } else {
0090 file_space = ::H5Screate_simple(1,dims,NULL);
0091 }
0092 if(file_space<0) {if(cpt>=0) ::H5Pclose(cpt);return false;}
0093 dataset = toolx_H5Dcreate(a_loc,a_name.c_str(),a_file_type,file_space,cpt);
0094 if(cpt>=0) ::H5Pclose(cpt);
0095 ::H5Sclose(file_space);
0096 if(dataset<0) return false;}
0097
0098 if(H5Dwrite(dataset,a_mem_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,a_array)<0) {
0099 ::H5Dclose(dataset);
0100 return false;
0101 }
0102 ::H5Dclose(dataset);
0103
0104 return true;
0105 }
0106
0107 template <class T>
0108 inline bool write_vlen(hid_t a_loc,const std::string& a_name,
0109 hid_t a_file_type,hid_t a_mem_type,
0110 unsigned int a_chunked,unsigned int a_compress,
0111 unsigned int a_size,const T a_array[]) {
0112 hid_t cpt = -1;
0113 if(a_compress || a_chunked) {
0114 cpt = ::H5Pcreate(H5P_DATASET_CREATE);
0115 if(cpt<0) return false;
0116 if(a_chunked) {
0117 if(H5Pset_layout(cpt,H5D_CHUNKED)<0) {
0118 ::H5Pclose(cpt);
0119 return false;
0120 }
0121 hsize_t cdims[1];
0122 cdims[0] = a_chunked;
0123 if(H5Pset_chunk(cpt,1,cdims)<0) {
0124 ::H5Pclose(cpt);
0125 return false;
0126 }
0127 } else {
0128 if(H5Pset_layout(cpt,H5D_COMPACT)<0) {
0129 ::H5Pclose(cpt);
0130 return false;
0131 }
0132 }
0133 if(a_compress) {
0134 if(H5Pset_deflate(cpt,a_compress>9?9:a_compress)<0) {
0135 ::H5Pclose(cpt);
0136 return false;
0137 }
0138 }
0139 } else {
0140 cpt = H5P_DEFAULT;
0141 }
0142
0143 hid_t dataset = -1;
0144
0145 {hsize_t dims[1];
0146 dims[0] = 1;
0147 hid_t file_space = -1;
0148 if(a_chunked) {
0149 hsize_t mx_dims[1];
0150 mx_dims[0] = H5S_UNLIMITED; //extendable.
0151 file_space = ::H5Screate_simple(1,dims,mx_dims);
0152 } else {
0153 file_space = ::H5Screate_simple(1,dims,NULL);
0154 }
0155 if(file_space<0) {if(cpt>=0) ::H5Pclose(cpt);return false;}
0156
0157 hid_t file_type = ::H5Tvlen_create(a_file_type);
0158
0159 dataset = toolx_H5Dcreate(a_loc,a_name.c_str(),file_type,file_space,cpt);
0160 if(cpt>=0) ::H5Pclose(cpt);
0161 ::H5Sclose(file_space);
0162 ::H5Tclose(file_type);
0163 if(dataset<0) return false;}
0164
0165 hid_t mem_type = ::H5Tvlen_create(a_mem_type);
0166
0167 hvl_t wdata[1];
0168 wdata[0].len = a_size;
0169 wdata[0].p = (void*)a_array;
0170
0171 if(H5Dwrite(dataset,mem_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata)<0) {
0172 ::H5Tclose(mem_type);
0173 ::H5Dclose(dataset);
0174 return false;
0175 }
0176 ::H5Tclose(mem_type);
0177 ::H5Dclose(dataset);
0178
0179 return true;
0180 }
0181
0182 template <class T>
0183 inline bool write_sub_array(hid_t a_loc,const std::string& a_name,
0184 hid_t a_file_type,hid_t a_mem_type,
0185 bool a_create,
0186 unsigned int a_chunked,unsigned int a_compress, // used if a_creat = true;
0187 unsigned int a_size,
0188 unsigned int a_offset,unsigned int a_number,const T a_array[]) {
0189
0190 int remain = a_size-a_offset;
0191 int number = (int(a_number)<=remain) ? int(a_number) : remain;
0192 if(number<=0) return false;
0193
0194 hid_t cpt = -1;
0195
0196 if(a_create) {
0197 if(a_compress || a_chunked) {
0198 cpt = ::H5Pcreate(H5P_DATASET_CREATE);
0199 if(cpt<0) return false;
0200 if(a_chunked) {
0201 if(H5Pset_layout(cpt,H5D_CHUNKED)<0) {
0202 ::H5Pclose(cpt);
0203 return false;
0204 }
0205 hsize_t cdims[1];
0206 cdims[0] = a_chunked;
0207 if(H5Pset_chunk(cpt,1,cdims)<0) {
0208 ::H5Pclose(cpt);
0209 return false;
0210 }
0211 } else {
0212 if(H5Pset_layout(cpt,H5D_COMPACT)<0) {
0213 ::H5Pclose(cpt);
0214 return false;
0215 }
0216 }
0217 if(a_compress) {
0218 if(H5Pset_deflate(cpt,a_compress>9?9:a_compress)<0) {
0219 ::H5Pclose(cpt);
0220 return false;
0221 }
0222 }
0223 } else {
0224 cpt = H5P_DEFAULT;
0225 }
0226 }
0227
0228 hid_t dataset = -1;
0229
0230 hid_t file_space = -1;
0231
0232 if(a_create) {
0233 hsize_t dims[1];
0234 dims[0] = a_size;
0235 file_space = ::H5Screate_simple(1,dims,NULL);
0236 if(file_space<0) {
0237 if(cpt>=0) ::H5Pclose(cpt);
0238 return false;
0239 }
0240
0241 {hsize_t offset[1];
0242 offset[0] = a_offset;
0243 hsize_t count[1];
0244 count[0] = number;
0245 if(H5Sselect_hyperslab(file_space,H5S_SELECT_SET,offset,NULL,count,NULL)<0) {
0246 ::H5Sclose(file_space);
0247 if(cpt>=0) ::H5Pclose(cpt);
0248 return false;
0249 }}
0250
0251 dataset = toolx_H5Dcreate(a_loc,a_name.c_str(),a_file_type,file_space,cpt);
0252 if(dataset<0) {
0253 ::H5Sclose(file_space);
0254 if(cpt>=0) ::H5Pclose(cpt);
0255 return false;
0256 }
0257
0258 } else { //open an existing dataset :
0259 dataset = toolx_H5Dopen(a_loc,a_name.c_str());
0260 if(dataset<0) {
0261 if(cpt>=0) ::H5Pclose(cpt);
0262 return false;
0263 }
0264
0265 file_space = H5Dget_space(dataset);
0266 if(file_space<0) {
0267 ::H5Dclose(dataset);
0268 if(cpt>=0) ::H5Pclose(cpt);
0269 return false;
0270 }
0271
0272 {hsize_t offset[1];
0273 offset[0] = a_offset;
0274 hsize_t count[1];
0275 count[0] = number;
0276 if(H5Sselect_hyperslab(file_space,H5S_SELECT_SET,offset,NULL,count,NULL)<0) {
0277 ::H5Sclose(file_space);
0278 ::H5Dclose(dataset);
0279 if(cpt>=0) ::H5Pclose(cpt);
0280 return false;
0281 }}
0282
0283 }
0284
0285 hsize_t dims[1];
0286 dims[0] = number;
0287 hid_t mem_space = ::H5Screate_simple(1,dims,NULL);
0288 if(mem_space<0) {
0289 ::H5Sclose(file_space);
0290 ::H5Dclose(dataset);
0291 if(cpt>=0) ::H5Pclose(cpt);
0292 return false;
0293 }
0294
0295 if(H5Dwrite(dataset,a_mem_type,mem_space,file_space,H5P_DEFAULT,a_array)<0) {
0296 ::H5Sclose(file_space);
0297 ::H5Dclose(dataset);
0298 if(cpt>=0) ::H5Pclose(cpt);
0299 return false;
0300 }
0301
0302 ::H5Sclose(file_space);
0303 ::H5Dclose(dataset);
0304 if(cpt>=0) ::H5Pclose(cpt);
0305
0306 return true;
0307 }
0308
0309 template <class T>
0310 inline bool write_append_array_dataset(hid_t a_dataset,hid_t /*a_file_type*/,hid_t a_mem_type,
0311 unsigned int a_number,const T a_array[]) {
0312 hsize_t old_size = 0;
0313
0314 {hid_t dataspace = H5Dget_space(a_dataset);
0315 if(dataspace<0) return false;
0316 hsize_t dims[1];
0317 if(H5Sget_simple_extent_dims(dataspace,dims,NULL)<0) {
0318 ::H5Sclose(dataspace);
0319 return false;
0320 }
0321 old_size = dims[0];
0322 ::H5Sclose(dataspace);}
0323
0324 {hsize_t exts[1];
0325 exts[0] = old_size+a_number;
0326 if(H5Dset_extent(a_dataset,exts)<0) return false;}
0327
0328 hid_t file_space = H5Dget_space(a_dataset);
0329 if(file_space<0) return false;
0330
0331 {hsize_t offset[1];
0332 offset[0] = old_size;
0333 hsize_t count[1];
0334 count[0] = a_number;
0335 if(H5Sselect_hyperslab(file_space,H5S_SELECT_SET,offset,NULL,count,NULL)<0) {
0336 ::H5Sclose(file_space);
0337 return false;
0338 }}
0339
0340 hsize_t dims[1];
0341 dims[0] = a_number;
0342 hid_t mem_space = ::H5Screate_simple(1,dims,NULL);
0343 if(mem_space<0) {
0344 ::H5Sclose(file_space);
0345 return false;
0346 }
0347
0348 if(H5Dwrite(a_dataset,a_mem_type,mem_space,file_space,H5P_DEFAULT,a_array)<0) {
0349 ::H5Sclose(mem_space);
0350 ::H5Sclose(file_space);
0351 return false;
0352 }
0353
0354 ::H5Sclose(mem_space);
0355 ::H5Sclose(file_space);
0356
0357 return true;
0358 }
0359
0360 template <class T>
0361 inline bool write_append_vlen_dataset(hid_t a_dataset,hid_t /*a_file_type*/,hid_t a_mem_type,
0362 unsigned int a_number,const T a_array[]) {
0363 hsize_t old_size = 0;
0364
0365 {hid_t dataspace = H5Dget_space(a_dataset);
0366 if(dataspace<0) return false;
0367 hsize_t dims[1];
0368 if(H5Sget_simple_extent_dims(dataspace,dims,NULL)<0) {
0369 ::H5Sclose(dataspace);
0370 return false;
0371 }
0372 old_size = dims[0];
0373 ::H5Sclose(dataspace);}
0374
0375 {hsize_t exts[1];
0376 exts[0] = old_size+1;
0377 if(H5Dset_extent(a_dataset,exts)<0) return false;}
0378
0379 hid_t file_space = H5Dget_space(a_dataset);
0380 if(file_space<0) return false;
0381
0382 {hsize_t offset[1];
0383 offset[0] = old_size;
0384 hsize_t count[1];
0385 count[0] = 1;
0386 if(H5Sselect_hyperslab(file_space,H5S_SELECT_SET,offset,NULL,count,NULL)<0) {
0387 ::H5Sclose(file_space);
0388 return false;
0389 }}
0390
0391 hsize_t dims[1];
0392 dims[0] = 1;
0393 hid_t mem_space = ::H5Screate_simple(1,dims,NULL);
0394 if(mem_space<0) {
0395 ::H5Sclose(file_space);
0396 return false;
0397 }
0398
0399 hid_t mem_type = ::H5Tvlen_create(a_mem_type);
0400
0401 hvl_t wdata[1];
0402 wdata[0].len = a_number;
0403 wdata[0].p = (void*)a_array;
0404
0405 if(H5Dwrite(a_dataset,mem_type,mem_space,file_space,H5P_DEFAULT,wdata)<0) {
0406 ::H5Tclose(mem_type);
0407 ::H5Sclose(mem_space);
0408 ::H5Sclose(file_space);
0409 return false;
0410 }
0411
0412 ::H5Tclose(mem_type);
0413 ::H5Sclose(mem_space);
0414 ::H5Sclose(file_space);
0415
0416 return true;
0417 }
0418
0419 template <class T>
0420 inline bool write_append_array(hid_t a_loc,const std::string& a_name,hid_t a_file_type,hid_t a_mem_type,
0421 unsigned int a_number,const T a_array[]) {
0422 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c_str());
0423 if(dataset<0) return false;
0424 bool status = write_append_array_dataset(dataset,a_file_type,a_mem_type,a_number,a_array);
0425 ::H5Dclose(dataset);
0426 return status;
0427 }
0428
0429 template <class T>
0430 inline bool read_scalar(hid_t a_loc,const std::string& a_name,hid_t a_mem_type,T& a_data) {
0431 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c_str());
0432 if(dataset<0) return false;
0433
0434 hid_t file_space = H5Dget_space(dataset);
0435 if(file_space<0) {
0436 ::H5Dclose(dataset);
0437 return false;
0438 }
0439
0440 hid_t mem_space = ::H5Screate(H5S_SCALAR);
0441 if(mem_space<0) {
0442 ::H5Sclose(file_space);
0443 ::H5Dclose(dataset);
0444 return false;
0445 }
0446
0447 if(H5Dread(dataset,a_mem_type,mem_space,file_space,H5P_DEFAULT,&a_data)<0) {
0448 ::H5Sclose(mem_space);
0449 ::H5Sclose(file_space);
0450 ::H5Dclose(dataset);
0451 return false;
0452 }
0453
0454 ::H5Sclose(mem_space);
0455 ::H5Sclose(file_space);
0456 ::H5Dclose(dataset);
0457
0458 return true;
0459 }
0460
0461 template <class T>
0462 inline bool read_array(hid_t a_loc,const std::string& a_name,hid_t a_mem_type,unsigned int& a_size,T*& a_array,bool a_alloc = true) {
0463 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c_str());
0464 if(dataset<0) {
0465 a_size = 0;
0466 if(a_alloc) a_array = 0;
0467 return false; // data set not found.
0468 }
0469
0470 hid_t file_space = H5Dget_space(dataset);
0471 if(file_space<0) {
0472 ::H5Dclose(dataset);
0473 a_size = 0;
0474 if(a_alloc) a_array = 0;
0475 return false;
0476 }
0477
0478 {int dimn = H5Sget_simple_extent_ndims(file_space);
0479 if(dimn<0) {
0480 ::H5Sclose(file_space);
0481 ::H5Dclose(dataset);
0482 a_size = 0;
0483 if(a_alloc) a_array = 0;
0484 return false;
0485 }
0486 if(dimn!=1) {
0487 ::H5Sclose(file_space);
0488 ::H5Dclose(dataset);
0489 a_size = 0;
0490 if(a_alloc) a_array = 0;
0491 return false;
0492 }
0493 }
0494
0495 hsize_t dims[1];
0496 {if(H5Sget_simple_extent_dims(file_space,dims,NULL)<0) {
0497 ::H5Sclose(file_space);
0498 ::H5Dclose(dataset);
0499 a_size = 0;
0500 if(a_alloc) a_array = 0;
0501 return false;
0502 }}
0503
0504 a_size = (unsigned int)dims[0];
0505 if(!a_size) {
0506 ::H5Sclose(file_space);
0507 ::H5Dclose(dataset);
0508 a_size = 0;
0509 if(a_alloc) a_array = 0;
0510 return true; //It is ok.
0511 }
0512
0513 hid_t mem_space = ::H5Screate_simple(1,dims,NULL);
0514 if(mem_space<0) {
0515 ::H5Sclose(file_space);
0516 ::H5Dclose(dataset);
0517 a_size = 0;
0518 if(a_alloc) a_array = 0;
0519 return false;
0520 }
0521
0522 if(a_alloc) a_array = new T[a_size];
0523 if(H5Dread(dataset,a_mem_type,mem_space,file_space,H5P_DEFAULT,a_array)<0) {
0524 if(a_alloc) delete [] a_array;
0525 ::H5Sclose(mem_space);
0526 ::H5Sclose(file_space);
0527 ::H5Dclose(dataset);
0528 a_size = 0;
0529 if(a_alloc) a_array = 0;
0530 return false;
0531 }
0532
0533
0534 ::H5Sclose(mem_space);
0535 ::H5Sclose(file_space);
0536 ::H5Dclose(dataset);
0537
0538 return true;
0539 }
0540
0541 template <class T>
0542 inline bool read_sub_array(hid_t a_loc,const std::string& a_name,hid_t a_mem_type,
0543 unsigned int a_offset,unsigned int a_number,
0544 unsigned int& a_size,T*& a_array) {
0545 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c_str());
0546 if(dataset<0) {
0547 a_size = 0;
0548 a_array = 0;
0549 return false; // data set not found.
0550 }
0551
0552 hid_t file_space = H5Dget_space(dataset);
0553 if(file_space<0) {
0554 ::H5Dclose(dataset);
0555 a_size = 0;
0556 a_array = 0;
0557 return false;
0558 }
0559
0560 {int dimn = H5Sget_simple_extent_ndims(file_space);
0561 if(dimn<0) {
0562 ::H5Sclose(file_space);
0563 ::H5Dclose(dataset);
0564 a_size = 0;
0565 a_array = 0;
0566 return false;
0567 }
0568 if(dimn!=1) {
0569 ::H5Sclose(file_space);
0570 ::H5Dclose(dataset);
0571 a_size = 0;
0572 a_array = 0;
0573 return false;
0574 }
0575 }
0576
0577 hsize_t dims[1];
0578 {if(H5Sget_simple_extent_dims(file_space,dims,NULL)<0) {
0579 ::H5Sclose(file_space);
0580 ::H5Dclose(dataset);
0581 a_size = 0;
0582 a_array = 0;
0583 return false;
0584 }}
0585
0586 unsigned int sz = (unsigned int)dims[0];
0587 if(!sz) {
0588 ::H5Sclose(file_space);
0589 ::H5Dclose(dataset);
0590 a_size = 0;
0591 a_array = 0;
0592 return true; //It is ok.
0593 }
0594
0595 // abcdef
0596 // 012345
0597 int remain = sz-a_offset;
0598 if(remain<=0) {
0599 ::H5Sclose(file_space);
0600 ::H5Dclose(dataset);
0601 a_size = 0;
0602 a_array = 0;
0603 return a_number?false:true;
0604 }
0605
0606 int number = (int(a_number)<=remain) ? int(a_number) : remain;
0607 if(number<=0) {
0608 ::H5Sclose(file_space);
0609 ::H5Dclose(dataset);
0610 a_size = 0;
0611 a_array = 0;
0612 return true; //It is ok.
0613 }
0614
0615 {hsize_t offset[1];
0616 offset[0] = a_offset;
0617 hsize_t count[1];
0618 count[0] = number;
0619 if(H5Sselect_hyperslab(file_space,H5S_SELECT_SET,offset,NULL,count,NULL)<0) {
0620 ::H5Sclose(file_space);
0621 ::H5Dclose(dataset);
0622 a_size = 0;
0623 a_array = 0;
0624 return false;
0625 }}
0626
0627 dims[0] = number;
0628 hid_t mem_space = ::H5Screate_simple(1,dims,NULL);
0629 if(mem_space<0) {
0630 ::H5Sclose(file_space);
0631 ::H5Dclose(dataset);
0632 a_size = 0;
0633 a_array = 0;
0634 return false;
0635 }
0636
0637 a_array = new T[number];
0638 if(H5Dread(dataset,a_mem_type,mem_space,file_space,H5P_DEFAULT,a_array)<0) {
0639 delete [] a_array;
0640 ::H5Sclose(mem_space);
0641 ::H5Sclose(file_space);
0642 ::H5Dclose(dataset);
0643 a_array = 0;
0644 return false;
0645 }
0646
0647 ::H5Sclose(mem_space);
0648 ::H5Sclose(file_space);
0649 ::H5Dclose(dataset);
0650
0651 a_size = number;
0652
0653 return true;
0654 }
0655
0656 template <class T>
0657 inline bool read_sub_vlen(hid_t a_loc,const std::string& a_name,hid_t a_mem_type,
0658 unsigned int a_offset,
0659 unsigned int& a_size,T*& a_array) {
0660 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c_str());
0661 if(dataset<0) {
0662 a_size = 0;
0663 a_array = 0;
0664 return false; // data set not found.
0665 }
0666
0667 hid_t file_space = H5Dget_space(dataset);
0668 if(file_space<0) {
0669 ::H5Dclose(dataset);
0670 a_size = 0;
0671 a_array = 0;
0672 return false;
0673 }
0674
0675 {int dimn = H5Sget_simple_extent_ndims(file_space);
0676 if(dimn<0) {
0677 ::H5Sclose(file_space);
0678 ::H5Dclose(dataset);
0679 a_size = 0;
0680 a_array = 0;
0681 return false;
0682 }
0683 if(dimn!=1) {
0684 ::H5Sclose(file_space);
0685 ::H5Dclose(dataset);
0686 a_size = 0;
0687 a_array = 0;
0688 return false;
0689 }
0690 }
0691
0692 hsize_t dims[1];
0693 {if(H5Sget_simple_extent_dims(file_space,dims,NULL)<0) {
0694 ::H5Sclose(file_space);
0695 ::H5Dclose(dataset);
0696 a_size = 0;
0697 a_array = 0;
0698 return false;
0699 }}
0700
0701 unsigned int sz = (unsigned int)dims[0];
0702 if(!sz) {
0703 ::H5Sclose(file_space);
0704 ::H5Dclose(dataset);
0705 a_size = 0;
0706 a_array = 0;
0707 return true; //It is ok.
0708 }
0709
0710 // abcdef
0711 // 012345
0712 int remain = sz-a_offset;
0713 if(remain<=0) {
0714 ::H5Sclose(file_space);
0715 ::H5Dclose(dataset);
0716 a_size = 0;
0717 a_array = 0;
0718 return false;
0719 }
0720
0721 {hsize_t offset[1];
0722 offset[0] = a_offset;
0723 hsize_t count[1];
0724 count[0] = 1;
0725 if(H5Sselect_hyperslab(file_space,H5S_SELECT_SET,offset,NULL,count,NULL)<0) {
0726 ::H5Sclose(file_space);
0727 ::H5Dclose(dataset);
0728 a_size = 0;
0729 a_array = 0;
0730 return false;
0731 }}
0732
0733 dims[0] = 1;
0734 hid_t mem_space = ::H5Screate_simple(1,dims,NULL);
0735 if(mem_space<0) {
0736 ::H5Sclose(file_space);
0737 ::H5Dclose(dataset);
0738 a_size = 0;
0739 a_array = 0;
0740 return false;
0741 }
0742
0743 hid_t mem_type = ::H5Tvlen_create(a_mem_type);
0744
0745 hvl_t rdata[1];
0746 if(H5Dread(dataset,mem_type,mem_space,file_space,H5P_DEFAULT,rdata)<0) {
0747 ::H5Tclose(mem_type);
0748 ::H5Sclose(mem_space);
0749 ::H5Sclose(file_space);
0750 ::H5Dclose(dataset);
0751 a_size = 0;
0752 a_array = 0;
0753 return false;
0754 }
0755
0756 hsize_t len = rdata[0].len;
0757 if(!len) {
0758 a_array = 0; //it is ok.
0759 } else {
0760 a_array = new T[len];
0761 T* _data = (T*)rdata[0].p;
0762 T* pos = a_array;
0763 for(hsize_t index=0;index<len;index++,pos++,_data++) *pos = *_data;
0764 }
0765 a_size = len;
0766
0767 ::H5Dvlen_reclaim(mem_type,mem_space,H5P_DEFAULT,rdata);
0768
0769 ::H5Tclose(mem_type);
0770 ::H5Sclose(mem_space);
0771 ::H5Sclose(file_space);
0772 ::H5Dclose(dataset);
0773
0774 return true;
0775 }
0776
0777 template <class TYPE>
0778 inline bool read_scalar(hid_t a_loc,const std::string& a_name,TYPE& aValue) {
0779 return read_scalar<TYPE>(a_loc,a_name,to_T_mem_type(TYPE()),aValue);
0780 }
0781
0782 template <class T>
0783 inline bool read_std_vec(hid_t a_loc,const std::string& a_name,hid_t a_mem_type,std::vector<T>& a_vec) {
0784 tools::uint64 sz;
0785 if(!read_scalar<tools::uint64>(a_loc,a_name+"_size",sz)) return false;
0786 if(!sz) {a_vec.clear();return true;} //it is ok.
0787 a_vec.resize((size_t)sz);
0788 T* data = a_vec.data();
0789 unsigned int _sz;
0790 if(!read_array(a_loc,a_name,a_mem_type,_sz,data,false)) return false; //false = do not alloc.
0791 if(tools::uint64(_sz)!=sz) {a_vec.clear();return false;}
0792 return true;
0793 }
0794
0795 template <class TYPE>
0796 inline bool read_std_vec_vec(hid_t a_loc,const std::string& a_name,hid_t a_mem_type,std::vector< std::vector<TYPE> >& a_vec_vec) {
0797 tools::uint64 sz;
0798 if(!read_scalar<tools::uint64>(a_loc,a_name+"_size",sz)) {a_vec_vec.clear();return false;}
0799 a_vec_vec.resize((size_t)sz);
0800 std::string scount;
0801 for(size_t count=0;count<(size_t)sz;count++) {
0802 tools::num2s(tools::uint64(count),scount);
0803 if(!read_std_vec<TYPE>(a_loc,a_name+"_elem_"+scount,a_mem_type,a_vec_vec[count])) {a_vec_vec.clear();return false;}
0804 }
0805 return true;
0806 }
0807
0808 template <class T>
0809 inline bool read_struct(hid_t a_loc,const std::string& a_name,hid_t aReadType,T& a_data) {
0810 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c_str());
0811 if(dataset<0) return false;
0812
0813 hid_t file_space = H5Dget_space(dataset);
0814 if(file_space<0) {
0815 ::H5Dclose(dataset);
0816 return false;
0817 }
0818
0819 hid_t mem_space = ::H5Screate(H5S_SCALAR);
0820 if(mem_space<0) {
0821 ::H5Sclose(file_space);
0822 ::H5Dclose(dataset);
0823 return false;
0824 }
0825
0826 if(H5Dread(dataset,aReadType,mem_space,file_space,H5P_DEFAULT,&a_data)<0) {
0827 ::H5Sclose(mem_space);
0828 ::H5Sclose(file_space);
0829 ::H5Dclose(dataset);
0830 return false;
0831 }
0832
0833 ::H5Sclose(mem_space);
0834 ::H5Sclose(file_space);
0835 ::H5Dclose(dataset);
0836 return true;
0837 }
0838
0839 template <class TYPE>
0840 inline bool write_scalar(hid_t a_loc,const std::string& a_name,const TYPE& aData) {
0841 hid_t scalar = ::H5Screate(H5S_SCALAR);
0842 if(scalar<0) return false;
0843
0844 hid_t compact = ::H5Pcreate(H5P_DATASET_CREATE);
0845 if(compact<0) {
0846 ::H5Sclose(scalar);
0847 return false;
0848 }
0849
0850 if(H5Pset_layout(compact,H5D_COMPACT)<0) {
0851 ::H5Pclose(compact);
0852 ::H5Sclose(scalar);
0853 return false;
0854 }
0855
0856 hid_t dataset = toolx_H5Dcreate(a_loc,a_name.c_str(),to_T_file_type(TYPE()),scalar,compact);
0857 if(dataset<0) {
0858 ::H5Pclose(compact);
0859 ::H5Sclose(scalar);
0860 return false;
0861 }
0862
0863 if(::H5Dwrite(dataset,to_T_mem_type(TYPE()),H5S_ALL,H5S_ALL,H5P_DEFAULT,&aData)<0) {
0864 ::H5Pclose(compact);
0865 ::H5Sclose(scalar);
0866 ::H5Dclose(dataset);
0867 return false;
0868 }
0869
0870 ::H5Pclose(compact);
0871 ::H5Sclose(scalar);
0872 ::H5Dclose(dataset);
0873 return true;
0874 }
0875
0876 template <class T>
0877 inline bool write_struct(hid_t a_loc,const std::string& a_name,
0878 hid_t a_create_type,hid_t aWriteType,const T& aData) {
0879 hid_t scalar = ::H5Screate(H5S_SCALAR);
0880 if(scalar<0) return false;
0881
0882 hid_t compact = ::H5Pcreate(H5P_DATASET_CREATE);
0883 if(compact<0) {
0884 ::H5Sclose(scalar);
0885 return false;
0886 }
0887
0888 if(H5Pset_layout(compact,H5D_COMPACT)<0) {
0889 ::H5Pclose(compact);
0890 ::H5Sclose(scalar);
0891 return false;
0892 }
0893
0894 hid_t dataset = toolx_H5Dcreate(a_loc,a_name.c_str(),a_create_type,scalar,compact);
0895 if(dataset<0) {
0896 ::H5Pclose(compact);
0897 ::H5Sclose(scalar);
0898 return false;
0899 }
0900
0901 if(H5Dwrite(dataset,aWriteType,H5S_ALL,H5S_ALL,H5P_DEFAULT,&aData)<0) {
0902 ::H5Pclose(compact);
0903 ::H5Sclose(scalar);
0904 ::H5Dclose(dataset);
0905 return false;
0906 }
0907
0908 ::H5Pclose(compact);
0909 ::H5Sclose(scalar);
0910 ::H5Dclose(dataset);
0911 return true;
0912 }
0913
0914 //////////////////////////////////////////////////////////////////////////////
0915 //////////////////////////////////////////////////////////////////////////////
0916 //////////////////////////////////////////////////////////////////////////////
0917 template <class TYPE>
0918 inline bool write_array(hid_t a_loc,const std::string& a_name,
0919 unsigned int a_size,const TYPE a_array[],
0920 unsigned int a_chunked = 0,unsigned int a_compress = 0) {
0921 return hdf5::write_array<TYPE>(a_loc,a_name,to_T_file_type(TYPE()),to_T_mem_type(TYPE()),
0922 a_chunked,a_compress,a_size,a_array);
0923 }
0924
0925 template <class TYPE>
0926 inline bool write_vlen(hid_t a_loc,const std::string& a_name,
0927 unsigned int a_size,const TYPE a_array[],
0928 unsigned int a_chunked = 0,unsigned int a_compress = 0) {
0929 return hdf5::write_vlen<TYPE>(a_loc,a_name,to_T_file_type(TYPE()),to_T_mem_type(TYPE()),
0930 a_chunked,a_compress,a_size,a_array);
0931 }
0932
0933 template <class T>
0934 inline bool write_std_vec(hid_t a_loc,const std::string& a_name,
0935 hid_t a_file_type,hid_t a_mem_type,
0936 unsigned int a_chunked,unsigned int a_compress,
0937 const std::vector<T>& a_vec) {
0938 if(!write_scalar<tools::uint64>(a_loc,a_name+"_size",a_vec.size())) return false;
0939 if(a_vec.empty()) return true; //it is ok.
0940 const T* data = a_vec.data();
0941 return write_array(a_loc,a_name,a_file_type,a_mem_type,a_chunked,a_compress,a_vec.size(),data);
0942 }
0943
0944 template <class TYPE>
0945 inline bool write_std_vec(hid_t a_loc,const std::string& a_name,const std::vector<TYPE>& a_array,
0946 unsigned int a_chunked = 0,unsigned int a_compress = 0) {
0947 return hdf5::write_std_vec<TYPE>(a_loc,a_name,to_T_file_type(TYPE()),to_T_mem_type(TYPE()),a_chunked,a_compress,a_array);
0948 }
0949
0950 template <class TYPE>
0951 inline bool write_std_vec_vec(hid_t a_loc,const std::string& a_name,const std::vector< std::vector<TYPE> >& a_vec_vec,
0952 unsigned int /*a_chunked*/ = 0,unsigned int /*a_compress*/ = 0) {
0953 if(!write_scalar<tools::uint64>(a_loc,a_name+"_size",a_vec_vec.size())) return false;
0954 unsigned int count = 0; //uint for num2s.
0955 std::string scount;
0956 for(auto it = a_vec_vec.cbegin(); it != a_vec_vec.cend(); ++it) {
0957 tools::num2s(count,scount);
0958 if(!write_std_vec<TYPE>(a_loc,a_name+"_elem_"+scount,*it)) return false;
0959 count++;
0960 }
0961 return true;
0962 }
0963
0964 template <class TYPE>
0965 inline bool write_sub_array(hid_t a_loc,const std::string& a_name,
0966 unsigned int a_size,unsigned int a_offset,unsigned int a_number,const TYPE a_array[],
0967 bool a_create = true,unsigned int a_chunked = 0,unsigned int a_compress = 0) {
0968 return hdf5::write_sub_array<TYPE>(a_loc,a_name,to_T_file_type(TYPE()),to_T_mem_type(TYPE()),
0969 a_create,a_chunked,a_compress,
0970 a_size,a_offset,a_number,a_array);
0971 }
0972
0973 template <class TYPE>
0974 inline bool write_append_array_dataset(hid_t a_dataset,unsigned int a_number,const TYPE a_array[]) {
0975 return hdf5::write_append_array_dataset<TYPE>(a_dataset,to_T_file_type(TYPE()),to_T_mem_type(TYPE()),a_number,a_array);
0976 }
0977
0978 template <class TYPE>
0979 inline bool write_append_vlen_dataset(hid_t a_dataset,unsigned int a_number,const TYPE a_array[]) {
0980 return hdf5::write_append_vlen_dataset<TYPE>(a_dataset,to_T_file_type(TYPE()),to_T_mem_type(TYPE()),a_number,a_array);
0981 }
0982
0983 template <class TYPE>
0984 inline bool write_append_array(hid_t a_loc,const std::string& a_name,unsigned int a_number,const TYPE a_array[]) {
0985 return hdf5::write_append_array<TYPE>(a_loc,a_name,to_T_file_type(TYPE()),to_T_mem_type(TYPE()),a_number,a_array);
0986 }
0987
0988 template <class TYPE>
0989 inline bool read_array(hid_t a_loc,const std::string& a_name,unsigned int& a_size,TYPE*& a_array) {
0990 return read_array<TYPE>(a_loc,a_name,to_T_mem_type(TYPE()),a_size,a_array);
0991 }
0992
0993 template <class TYPE>
0994 inline bool read_std_vec(hid_t a_loc,const std::string& a_name,std::vector<TYPE>& a_vec) {
0995 return read_std_vec<TYPE>(a_loc,a_name,to_T_mem_type(TYPE()),a_vec);
0996 }
0997
0998 template <class TYPE>
0999 inline bool read_std_vec_vec(hid_t a_loc,const std::string& a_name,std::vector< std::vector<TYPE> >& a_vec_vec) {
1000 return read_std_vec_vec<TYPE>(a_loc,a_name,to_T_mem_type(TYPE()),a_vec_vec);
1001 }
1002
1003 template <class TYPE>
1004 inline bool read_sub_array(hid_t a_loc,const std::string& a_name,unsigned int a_offset,unsigned int a_number,
1005 unsigned int& a_size,TYPE*& a_array) {
1006 return read_sub_array<TYPE>(a_loc,a_name,to_T_mem_type(TYPE()),a_offset,a_number,a_size,a_array);
1007 }
1008
1009 template <class TYPE>
1010 inline bool read_sub_vlen(hid_t a_loc,const std::string& a_name,unsigned int a_offset,
1011 unsigned int& a_size,TYPE*& a_array) {
1012 return read_sub_vlen<TYPE>(a_loc,a_name,to_T_mem_type(TYPE()),a_offset,a_size,a_array);
1013 }
1014
1015 inline bool read_bool(hid_t a_loc,const std::string& a_name,bool& aValue) {
1016 unsigned char value = 0;
1017 if(!read_scalar<unsigned char>(a_loc,a_name,H5T_NATIVE_UCHAR,value)) {
1018 aValue = false;
1019 return false;
1020 }
1021 if((value!=0) && (value!=1)) {
1022 aValue = false;
1023 return false;
1024 }
1025 aValue = (value==1?true:false);
1026 return true;
1027 }
1028
1029 }}
1030
1031 #include "atb"
1032
1033 namespace toolx {
1034 namespace hdf5 {
1035
1036 template <class TYPE>
1037 inline bool write_scalar_atb(hid_t aDS,const std::string& a_name,const TYPE& aData) {
1038 int has_attr = H5LT_find_attribute(aDS,a_name.c_str());
1039 if(has_attr==1) {
1040 if(H5Adelete(aDS,a_name.c_str())<0) return false;
1041 }
1042
1043 hid_t scalar = ::H5Screate(H5S_SCALAR);
1044 if(scalar<0) return false;
1045
1046 hid_t aid = toolx_H5Acreate(aDS,a_name.c_str(),to_T_file_type(TYPE()),scalar,H5P_DEFAULT);
1047 if(aid<0) {
1048 ::H5Sclose(scalar);
1049 return false;
1050 }
1051
1052 if(H5Awrite(aid,to_T_mem_type(TYPE()),&aData)<0) {
1053 ::H5Sclose(scalar);
1054 ::H5Aclose(aid);
1055 return false;
1056 }
1057
1058 ::H5Sclose(scalar);
1059 ::H5Aclose(aid);
1060
1061 return true;
1062 }
1063
1064 }}
1065
1066 #endif
