Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 2 // See the file tools.license for terms. 3 4 #ifndef toolx_hdf5_tools 5 #define toolx_hdf5_tools 6 7 #include "hdf5_h" 8 9 #include <cstdlib> 10 11 namespace toolx { 12 namespace hdf5 { 13 14 inline bool check_sizes(){ 15 if(sizeof(bool)!=1) return false; 16 if(sizeof(char)!=1) return false; 17 if(sizeof(short)!=2) return false; 18 if(sizeof(int)!=4) return false; 19 if(sizeof(float)!=4) return false; 20 if(sizeof(double)!=8) return false; 21 return true; 22 } 23 24 inline int failure() {return -1;} 25 26 inline hid_t string_datatype(size_t aSize){ 27 // aSize should include the trailing null ch 28 hid_t datatype = ::H5Tcopy(H5T_C_S1); 29 if(datatype<0) return failure(); 30 31 if(::H5Tset_size(datatype,aSize)<0) { 32 ::H5Tclose(datatype); 33 return failure(); 34 } 35 36 if(::H5Tset_strpad(datatype,H5T_STR_NULLTERM 37 ::H5Tclose(datatype); 38 return failure(); 39 } 40 41 return datatype; 42 } 43 44 inline hid_t str_datatype() { 45 hid_t datatype = ::H5Tcopy(H5T_C_S1); 46 if(datatype<0) return failure(); 47 if(::H5Tset_size(datatype,H5T_VARIABLE)<0) { 48 ::H5Tclose(datatype); 49 return failure(); 50 } 51 if(::H5Tset_strpad(datatype,H5T_STR_NULLTERM 52 ::H5Tclose(datatype); 53 return failure(); 54 } 55 return datatype; 56 } 57 58 inline hid_t basic_mem_type(hid_t a_file_type) 59 H5T_class_t mclass = H5Tget_class(a_file_typ 60 size_t msize = H5Tget_size(a_file_type); 61 if(mclass==H5T_INTEGER) { 62 H5T_sign_t msign = H5Tget_sign(a_file_type 63 if(msize==1) { 64 if(msign==H5T_SGN_NONE) { 65 return H5Tcopy(H5T_NATIVE_UCHAR); 66 } else { 67 return H5Tcopy(H5T_NATIVE_CHAR); 68 } 69 } else if(msize==4) { 70 if(msign==H5T_SGN_NONE) { 71 return H5Tcopy(H5T_NATIVE_UINT); 72 } else { 73 return H5Tcopy(H5T_NATIVE_INT); 74 } 75 } else if(msize==8) { //for osc_file::head 76 if(msign==H5T_SGN_NONE) { 77 return H5Tcopy(H5T_NATIVE_UINT64); 78 } else { 79 return H5Tcopy(H5T_NATIVE_INT64); 80 } 81 } else { 82 return failure(); 83 } 84 } else if(mclass==H5T_FLOAT) { 85 if(msize==4) { 86 return H5Tcopy(H5T_NATIVE_FLOAT); 87 } else if(msize==8) { 88 return H5Tcopy(H5T_NATIVE_DOUBLE); 89 } else { 90 return failure(); 91 } 92 } else if(mclass==H5T_STRING) { 93 return H5Tcopy(a_file_type); 94 } 95 96 return failure(); 97 } 98 99 }} 100 101 #include <vector> 102 103 namespace toolx { 104 namespace hdf5 { 105 106 inline hid_t compound_mem_type(hid_t a_file_ty 107 // FIXME : In principle H5T_get_native_type 108 109 H5T_class_t t_class = H5Tget_class(a_file_ty 110 if(t_class!=H5T_COMPOUND) return failure(); 111 112 size_t sz = H5Tget_size(a_file_type); 113 //printf("debug : compound_mem_type : sz %lu 114 115 hid_t mem_type = ::H5Tcreate(H5T_COMPOUND,sz 116 if(mem_type<0) return failure(); 117 118 //FIXME : WARNING : is order the booked orde 119 120 int mn = H5Tget_nmembers(a_file_type); 121 std::vector<unsigned int> szs(mn); 122 //printf("debug : members : %d\n",mn); 123 for(int index=0;index<mn;index++) { 124 char* mname = H5Tget_member_name(a_file_ty 125 size_t moffset = H5Tget_member_offset(a_fi 126 hid_t mtype = H5Tget_member_type(a_file_ty 127 //printf("debug : members : %d (%d) : %s 128 129 {H5T_class_t mclass = H5Tget_class(mtype); 130 if( (mclass==H5T_INTEGER) || 131 (mclass==H5T_STRING) || 132 (mclass==H5T_FLOAT) ) { 133 hid_t mmem_type = basic_mem_type(mtype); 134 if(mmem_type<0) { 135 ::H5Tclose(mtype); 136 if(mname) toolx_H5free_memory(mname); 137 ::H5Tclose(mem_type); 138 return failure(); 139 } 140 if(H5Tinsert(mem_type,mname,moffset,mmem 141 ::H5Tclose(mmem_type); 142 ::H5Tclose(mtype); 143 if(mname) toolx_H5free_memory(mname); 144 ::H5Tclose(mem_type); 145 return failure(); 146 } 147 ::H5Tclose(mmem_type); 148 149 } else if(mclass==H5T_ARRAY) { 150 int dimn = ::H5Tget_array_ndims(mtype); 151 hsize_t* dims = new hsize_t[dimn]; 152 int* perms = new int[dimn]; 153 if(toolx_H5Tget_array_dims(mtype,dims,pe 154 delete [] dims; 155 delete [] perms; 156 ::H5Tclose(mtype); 157 if(mname) toolx_H5free_memory(mname); 158 ::H5Tclose(mem_type); 159 return failure(); 160 } 161 hid_t base_type = H5Tget_super(mtype); 162 if(base_type<0) { 163 delete [] dims; 164 delete [] perms; 165 ::H5Tclose(mtype); 166 if(mname) toolx_H5free_memory(mname); 167 ::H5Tclose(mem_type); 168 return failure(); 169 } 170 hid_t mmem_type = basic_mem_type(base_ty 171 if(mmem_type<0) { 172 delete [] dims; 173 delete [] perms; 174 ::H5Tclose(base_type); 175 ::H5Tclose(mtype); 176 if(mname) toolx_H5free_memory(mname); 177 ::H5Tclose(mem_type); 178 return failure(); 179 } 180 ::H5Tclose(base_type); 181 hid_t array_type = toolx_H5Tarray_create 182 delete [] dims; 183 delete [] perms; 184 if(array_type<0) { 185 ::H5Tclose(mmem_type); 186 ::H5Tclose(mtype); 187 if(mname) toolx_H5free_memory(mname); 188 ::H5Tclose(mem_type); 189 return failure(); 190 } 191 ::H5Tclose(mmem_type); 192 193 if(H5Tinsert(mem_type,mname,moffset,arra 194 ::H5Tclose(array_type); 195 ::H5Tclose(mtype); 196 if(mname) toolx_H5free_memory(mname); 197 ::H5Tclose(mem_type); 198 return failure(); 199 } 200 ::H5Tclose(array_type); 201 202 } else if(mclass==H5T_COMPOUND) { 203 hid_t mmem_type = compound_mem_type(mtyp 204 if(mem_type<0) { 205 ::H5Tclose(mtype); 206 if(mname) toolx_H5free_memory(mname); 207 ::H5Tclose(mem_type); 208 return failure(); 209 } 210 if(H5Tinsert(mem_type,mname,moffset,mmem 211 ::H5Tclose(mmem_type); 212 ::H5Tclose(mtype); 213 if(mname) toolx_H5free_memory(mname); 214 ::H5Tclose(mem_type); 215 return failure(); 216 } 217 ::H5Tclose(mmem_type); 218 } else { 219 ::H5Tclose(mtype); 220 if(mname) toolx_H5free_memory(mname); 221 ::H5Tclose(mem_type); 222 return failure(); 223 }} 224 ::H5Tclose(mtype); 225 //printf("debug : compound_mem_type : %d 226 if(mname) toolx_H5free_memory(mname); 227 } 228 229 return mem_type; 230 } 231 232 }} 233 234 #include "atb" 235 #include <string> 236 237 namespace toolx { 238 namespace hdf5 { 239 240 inline bool read_atb(hid_t a_id,const std::str 241 // From H5LT.c/H5LTget_attribute_string. 242 if(!H5LT_find_attribute(a_id,a_name.c_str()) 243 char* b = new char[aSize]; 244 if(H5LT_get_attribute_disk(a_id,a_name.c_str 245 delete [] b; 246 a_data.clear(); 247 return false; 248 } 249 a_data = std::string(b); 250 delete [] b; 251 return true; 252 } 253 254 inline bool read_atb(hid_t a_id,const std::str 255 if(!H5LT_find_attribute(a_id,a_name.c_str()) 256 if(H5LT_get_attribute_mem(a_id,a_name.c_str( 257 return true; 258 } 259 260 inline bool read_atb(hid_t a_id,const std::str 261 if(!H5LT_find_attribute(a_id,a_name.c_str()) 262 if(H5LT_get_attribute_mem(a_id,a_name.c_str( 263 return true; 264 } 265 266 inline hid_t H5T_STD_U8XX() {return H5T_STD_U8 267 inline hid_t H5T_STD_U32XX() {return H5T_STD_U 268 inline hid_t H5T_STD_U64XX() {return H5T_STD_U 269 inline hid_t H5T_STD_I8XX() {return H5T_STD_I8 270 inline hid_t H5T_STD_I16XX() {return H5T_STD_I 271 inline hid_t H5T_STD_I32XX() {return H5T_STD_I 272 inline hid_t H5T_STD_I64XX() {return H5T_STD_I 273 inline hid_t H5T_IEEE_F32XX() {return H5T_IEEE 274 inline hid_t H5T_IEEE_F64XX() {return H5T_IEEE 275 276 inline bool dataset_vec_size(hid_t a_loc,const 277 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c 278 if(dataset<0) { 279 a_size = 0; 280 return false; // data set not found. 281 } 282 283 hid_t file_space = H5Dget_space(dataset); 284 if(file_space<0) { 285 ::H5Dclose(dataset); 286 a_size = 0; 287 return false; 288 } 289 290 int dimn = H5Sget_simple_extent_ndims(file_s 291 if(dimn<0) { 292 ::H5Sclose(file_space); 293 ::H5Dclose(dataset); 294 a_size = 0; 295 return false; 296 } 297 if(dimn!=1) { 298 ::H5Sclose(file_space); 299 ::H5Dclose(dataset); 300 a_size = 0; 301 return false; 302 } 303 //printf("debug : read dimn %d\n",dimn); 304 305 hsize_t dims[1]; 306 {if(H5Sget_simple_extent_dims(file_space,dims 307 ::H5Sclose(file_space); 308 ::H5Dclose(dataset); 309 a_size = 0; 310 return false; 311 }} 312 313 ::H5Sclose(file_space); 314 ::H5Dclose(dataset); 315 316 a_size = dims[0]; 317 return true; 318 } 319 320 inline bool write_atb(hid_t a_id,const std::st 321 // From H5LT.c/H5LTset_attribute_string. 322 int has_attr = H5LT_find_attribute(a_id,a_na 323 if(has_attr==1) { 324 if(H5Adelete(a_id,a_name.c_str())<0) retur 325 } 326 327 hid_t datatype = string_datatype(a_data.size 328 if(datatype<0) return false; 329 330 hid_t scalar = ::H5Screate(H5S_SCALAR); 331 if(scalar<0) { 332 ::H5Tclose(datatype); 333 return false; 334 } 335 336 hid_t aid = toolx_H5Acreate(a_id,a_name.c_st 337 if(aid<0) { 338 ::H5Sclose(scalar); 339 ::H5Tclose(datatype); 340 return false; 341 } 342 343 if(H5Awrite(aid,datatype,a_data.c_str())<0) 344 ::H5Aclose(aid); 345 ::H5Sclose(scalar); 346 ::H5Tclose(datatype); 347 return false; 348 } 349 350 ::H5Aclose(aid); 351 ::H5Sclose(scalar); 352 ::H5Tclose(datatype); 353 354 return true; 355 } 356 357 inline bool write_bool(hid_t a_loc,const std:: 358 hid_t scalar = ::H5Screate(H5S_SCALAR); 359 if(scalar<0) return false; 360 361 hid_t compact = ::H5Pcreate(H5P_DATASET_CREA 362 if(compact<0) { 363 ::H5Sclose(scalar); 364 return false; 365 } 366 if(H5Pset_layout(compact,H5D_COMPACT)<0) { 367 ::H5Pclose(compact); 368 ::H5Sclose(scalar); 369 return false; 370 } 371 372 hid_t dataset = toolx_H5Dcreate(a_loc,a_name 373 if(dataset<0) { 374 ::H5Pclose(compact); 375 ::H5Sclose(scalar); 376 return false; 377 } 378 379 unsigned char data = a_data?1:0; 380 if(::H5Dwrite(dataset,H5T_NATIVE_UCHAR,H5S_A 381 ::H5Pclose(compact); 382 ::H5Sclose(scalar); 383 ::H5Dclose(dataset); 384 return false; 385 } 386 387 ::H5Pclose(compact); 388 ::H5Sclose(scalar); 389 ::H5Dclose(dataset); 390 return true; 391 } 392 393 inline bool write_string(hid_t a_loc,const std 394 hid_t scalar = ::H5Screate(H5S_SCALAR); 395 if(scalar<0) return false; 396 397 hid_t compact = ::H5Pcreate(H5P_DATASET_CREA 398 if(compact<0) { 399 ::H5Sclose(scalar); 400 return false; 401 } 402 403 if(H5Pset_layout(compact,H5D_COMPACT)<0) { 404 ::H5Pclose(compact); 405 ::H5Sclose(scalar); 406 return false; 407 } 408 409 // From H5LTmakge_dataset_string. 410 hid_t file_type = string_datatype(a_string.s 411 if(file_type<0) { 412 ::H5Pclose(compact); 413 ::H5Sclose(scalar); 414 return false; 415 } 416 417 hid_t dataset = toolx_H5Dcreate(a_loc,a_name 418 if(dataset<0) { 419 ::H5Pclose(compact); 420 ::H5Sclose(scalar); 421 ::H5Tclose(file_type); 422 return false; 423 } 424 425 hid_t mem_type = file_type; 426 if(H5Dwrite(dataset,mem_type,H5S_ALL,H5S_ALL 427 ::H5Pclose(compact); 428 ::H5Sclose(scalar); 429 ::H5Dclose(dataset); 430 ::H5Tclose(file_type); 431 return false; 432 } 433 434 ::H5Pclose(compact); 435 ::H5Sclose(scalar); 436 ::H5Dclose(dataset); 437 ::H5Tclose(file_type); 438 439 return true; 440 } 441 442 inline bool write_string_dataset(hid_t a_loc,c 443 unsigned int 444 const std::st 445 hid_t cpt = -1; 446 if(a_compress || a_chunked) { 447 cpt = ::H5Pcreate(H5P_DATASET_CREATE); 448 if(cpt<0) return false; 449 if(a_chunked) { 450 if(H5Pset_layout(cpt,H5D_CHUNKED)<0) { 451 ::H5Pclose(cpt); 452 return false; 453 } 454 hsize_t cdims[1]; 455 cdims[0] = a_chunked; 456 if(H5Pset_chunk(cpt,1,cdims)<0) { 457 ::H5Pclose(cpt); 458 return false; 459 } 460 } else { 461 if(H5Pset_layout(cpt,H5D_COMPACT)<0) { 462 ::H5Pclose(cpt); 463 return false; 464 } 465 } 466 if(a_compress) { 467 if(H5Pset_deflate(cpt,a_compress>9?9:a_c 468 ::H5Pclose(cpt); 469 return false; 470 } 471 } 472 } else { 473 cpt = H5P_DEFAULT; 474 } 475 476 hid_t file_type = str_datatype(); //first in 477 if(file_type<0) { 478 if(cpt>=0) ::H5Pclose(cpt); 479 return false; 480 } 481 482 hid_t file_space = -1; 483 {hsize_t dims[1]; 484 dims[0] = 1; 485 if(a_chunked) { 486 hsize_t mx_dims[1]; 487 mx_dims[0] = H5S_UNLIMITED; //extendable. 488 file_space = ::H5Screate_simple(1,dims,mx_ 489 } else { 490 file_space = ::H5Screate_simple(1,dims,NUL 491 } 492 if(file_space<0) {if(cpt>=0) ::H5Pclose(cpt) 493 494 hid_t dataset = toolx_H5Dcreate(a_loc,a_name 495 if(cpt>=0) ::H5Pclose(cpt); 496 ::H5Sclose(file_space); 497 if(dataset<0) { 498 ::H5Tclose(file_type); 499 return false; 500 } 501 502 hid_t mem_type = file_type; 503 504 const char* wdata[1]; 505 wdata[0] = a_string.c_str(); 506 507 if(H5Dwrite(dataset,mem_type,H5S_ALL,H5S_ALL 508 ::H5Dclose(dataset); 509 ::H5Tclose(file_type); 510 return false; 511 } 512 513 ::H5Tclose(file_type); 514 ::H5Dclose(dataset); 515 516 return true; 517 } 518 519 inline bool write_string_dataset(hid_t a_loc,c 520 const std::st 521 unsigned int 522 return hdf5::write_string_dataset(a_loc,a_na 523 } 524 525 inline bool write_append_string_dataset(hid_t 526 hsize_t old_size = 0; 527 528 {hid_t dataspace = H5Dget_space(a_dataset); 529 if(dataspace<0) return false; 530 hsize_t dims[1]; 531 if(H5Sget_simple_extent_dims(dataspace,dims, 532 ::H5Sclose(dataspace); 533 return false; 534 } 535 old_size = dims[0]; 536 ::H5Sclose(dataspace);} 537 538 {hsize_t exts[1]; 539 exts[0] = old_size+1; 540 // if(H5Dextend(dataset,exts)<0) { 541 if(H5Dset_extent(a_dataset,exts)<0) return f 542 543 hid_t file_space = H5Dget_space(a_dataset); 544 if(file_space<0) return false; 545 546 {hsize_t offset[1]; 547 offset[0] = old_size; 548 hsize_t count[1]; 549 count[0] = 1; 550 if(H5Sselect_hyperslab(file_space,H5S_SELECT 551 ::H5Sclose(file_space); 552 return false; 553 }} 554 555 hsize_t dims[1]; 556 dims[0] = 1; 557 hid_t mem_space = ::H5Screate_simple(1,dims, 558 if(mem_space<0) { 559 ::H5Sclose(file_space); 560 return false; 561 } 562 563 hid_t mem_type = str_datatype(); 564 if(mem_type<0) { 565 ::H5Sclose(mem_space); 566 ::H5Sclose(file_space); 567 return false; 568 } 569 570 const char* wdata[1]; 571 wdata[0] = a_string.c_str(); 572 573 if(H5Dwrite(a_dataset,mem_type,mem_space,fil 574 ::H5Tclose(mem_type); 575 ::H5Sclose(mem_space); 576 ::H5Sclose(file_space); 577 return false; 578 } 579 580 ::H5Tclose(mem_type); 581 ::H5Sclose(mem_space); 582 ::H5Sclose(file_space); 583 584 return true; 585 } 586 587 }} 588 589 #include <tools/buf2lines> 590 591 namespace toolx { 592 namespace hdf5 { 593 594 inline bool write_array_string(hid_t a_loc,con 595 hid_t scalar = ::H5Screate(H5S_SCALAR); 596 if(scalar<0) return false; 597 598 // From H5LTmake_dataset_string. 599 size_t sz; 600 char* buffer; 601 if(!tools::strings2buf(a_array,sz,buffer)) { 602 ::H5Sclose(scalar); 603 return false; 604 } 605 606 hid_t file_type = string_datatype(sz); 607 if(file_type<0) { 608 delete [] buffer; 609 ::H5Sclose(scalar); 610 return false; 611 } 612 613 hid_t dataset = toolx_H5Dcreate(a_loc,a_name 614 if(dataset<0) { 615 delete [] buffer; 616 ::H5Tclose(file_type); 617 ::H5Sclose(scalar); 618 return false; 619 } 620 621 hid_t mem_type = file_type; 622 if(H5Dwrite(dataset,mem_type,H5S_ALL,H5S_ALL 623 delete [] buffer; 624 ::H5Dclose(dataset); 625 ::H5Tclose(file_type); 626 ::H5Sclose(scalar); 627 return false; 628 } 629 630 delete [] buffer; 631 632 ::H5Dclose(dataset); 633 ::H5Tclose(file_type); 634 ::H5Sclose(scalar); 635 return true; 636 } 637 638 inline bool write_object(hid_t a_loc,const std 639 unsigned int chunked = 0; 640 unsigned int compress = 0; 641 642 hid_t cpt = -1; 643 if(compress || chunked) { 644 cpt = ::H5Pcreate(H5P_DATASET_CREATE); 645 if(cpt<0) return false; 646 if(chunked) { 647 if(H5Pset_layout(cpt,H5D_CHUNKED)<0) { 648 ::H5Pclose(cpt); 649 return false; 650 } 651 hsize_t cdims[1]; 652 cdims[0] = chunked; 653 if(H5Pset_chunk(cpt,1,cdims)<0) { 654 ::H5Pclose(cpt); 655 return false; 656 } 657 } else { 658 if(H5Pset_layout(cpt,H5D_COMPACT)<0) { 659 ::H5Pclose(cpt); 660 return false; 661 } 662 } 663 if(compress) { 664 if(H5Pset_deflate(cpt,compress>9?9:compr 665 ::H5Pclose(cpt); 666 return false; 667 } 668 } 669 } else { 670 cpt = H5P_DEFAULT; 671 } 672 673 hsize_t dims[1]; 674 dims[0] = 1; 675 hid_t simple = ::H5Screate_simple(1,dims,NUL 676 if(simple<0) { 677 if(cpt>=0) ::H5Pclose(cpt); 678 return false; 679 } 680 681 hid_t mem_type = compound_mem_type(a_file_ty 682 if(mem_type<0) { 683 ::H5Sclose(simple); 684 if(cpt>=0) ::H5Pclose(cpt); 685 return false; 686 } 687 688 hid_t dataset = toolx_H5Dcreate(a_loc,a_name 689 if(dataset<0) { 690 ::H5Tclose(mem_type); 691 ::H5Sclose(simple); 692 if(cpt>=0) ::H5Pclose(cpt); 693 return false; 694 } 695 696 if(H5Dwrite(dataset,mem_type,H5S_ALL,H5S_ALL 697 ::H5Dclose(dataset); 698 ::H5Tclose(mem_type); 699 ::H5Sclose(simple); 700 if(cpt>=0) ::H5Pclose(cpt); 701 return false; 702 } 703 704 ::H5Dclose(dataset); 705 ::H5Tclose(mem_type); 706 ::H5Sclose(simple); 707 if(cpt>=0) ::H5Pclose(cpt); 708 709 return true; 710 } 711 712 inline bool read_string(hid_t a_loc,const std: 713 // From H5LTread_dataset_string. 714 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c 715 if(dataset<0) { 716 a_string.clear(); 717 return false; // data set not found. 718 } 719 720 hid_t file_type = H5Dget_type(dataset); 721 if(file_type<0) { 722 ::H5Dclose(dataset); 723 a_string.clear(); 724 return false; 725 } 726 727 H5T_class_t t_class = H5Tget_class(file_type 728 if(t_class!=H5T_STRING) { 729 ::H5Tclose(file_type); 730 ::H5Dclose(dataset); 731 a_string.clear(); 732 return false; 733 } 734 735 size_t sz = H5Tget_size(file_type); 736 ::H5Tclose(file_type); 737 if(!sz) { 738 ::H5Dclose(dataset); 739 a_string.clear(); 740 return false; 741 } 742 743 // We could have use file_type since, for st 744 // file type is the same than memory type. 745 hid_t mem_type = string_datatype(sz); 746 if(mem_type<0) { 747 ::H5Dclose(dataset); 748 a_string.clear(); 749 return false; 750 } 751 752 char* buff = new char[sz]; 753 herr_t stat = H5Dread(dataset,mem_type,H5S_A 754 ::H5Tclose(mem_type); 755 ::H5Dclose(dataset); 756 if(stat<0) { 757 delete [] buff; 758 a_string.clear(); 759 return false; 760 } 761 762 size_t len = sz-1; 763 a_string.resize(len,0); 764 for(size_t index=0;index<len;index++) a_stri 765 766 delete [] buff; 767 768 return true; 769 } 770 771 inline bool read_sub_string(hid_t a_loc,const 772 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c 773 if(dataset<0) { 774 a_string.clear(); 775 return false; // data set not found. 776 } 777 778 hid_t file_space = H5Dget_space(dataset); 779 if(file_space<0) { 780 ::H5Dclose(dataset); 781 a_string.clear(); 782 return false; 783 } 784 785 {int dimn = H5Sget_simple_extent_ndims(file_s 786 if(dimn<0) { 787 ::H5Sclose(file_space); 788 ::H5Dclose(dataset); 789 a_string.clear(); 790 return false; 791 } 792 if(dimn!=1) { 793 ::H5Sclose(file_space); 794 ::H5Dclose(dataset); 795 a_string.clear(); 796 return false; 797 }} 798 799 hsize_t dims[1]; 800 {if(H5Sget_simple_extent_dims(file_space,dims 801 ::H5Sclose(file_space); 802 ::H5Dclose(dataset); 803 a_string.clear(); 804 return false; 805 }} 806 807 {unsigned int sz = (unsigned int)dims[0]; 808 if(!sz) { 809 ::H5Sclose(file_space); 810 ::H5Dclose(dataset); 811 a_string.clear(); 812 return false; //Is it ok ? 813 } 814 815 // abcdef 816 // 012345 817 int remain = sz-a_offset; 818 if(remain<=0) { 819 ::H5Sclose(file_space); 820 ::H5Dclose(dataset); 821 a_string.clear(); 822 return false; 823 }} 824 825 {hsize_t offset[1]; 826 offset[0] = a_offset; 827 hsize_t count[1]; 828 count[0] = 1; 829 if(H5Sselect_hyperslab(file_space,H5S_SELECT 830 ::H5Sclose(file_space); 831 ::H5Dclose(dataset); 832 a_string.clear(); 833 return false; 834 }} 835 836 dims[0] = 1; 837 hid_t mem_space = ::H5Screate_simple(1,dims, 838 if(mem_space<0) { 839 ::H5Sclose(file_space); 840 ::H5Dclose(dataset); 841 a_string.clear(); 842 return false; 843 } 844 845 hid_t file_type = H5Dget_type(dataset); 846 if(file_type<0) { 847 ::H5Sclose(file_space); 848 ::H5Dclose(dataset); 849 a_string.clear(); 850 return false; 851 } 852 853 H5T_class_t t_class = H5Tget_class(file_type 854 if(t_class!=H5T_STRING) { 855 ::H5Tclose(file_type); 856 ::H5Sclose(file_space); 857 ::H5Dclose(dataset); 858 a_string.clear(); 859 return false; 860 } 861 862 //size_t sz = H5Tget_size(file_type); //it giv 863 //if(!sz) { 864 // ::H5Tclose(file_type); 865 // ::H5Sclose(file_space); 866 // ::H5Dclose(dataset); 867 // a_string.clear(); 868 // return false; 869 //} 870 871 ::H5Tclose(file_type); 872 873 hid_t mem_type = str_datatype(); 874 if(mem_type<0) { 875 ::H5Sclose(file_space); 876 ::H5Dclose(dataset); 877 a_string.clear(); 878 return false; 879 } 880 881 char* rdata[1]; 882 herr_t stat = H5Dread(dataset,mem_type,mem_s 883 if(stat<0) { 884 ::H5Dvlen_reclaim(mem_type,mem_space, H5P_ 885 ::H5Tclose(mem_type); 886 ::H5Sclose(mem_space); 887 ::H5Sclose(file_space); 888 ::H5Dclose(dataset); 889 a_string.clear(); 890 return false; 891 } 892 893 char* buff = rdata[0]; 894 895 size_t len = ::strlen(buff); 896 a_string.resize(len,0); 897 for(size_t index=0;index<len;index++) a_stri 898 899 ::H5Dvlen_reclaim(mem_type,mem_space, H5P_DE 900 901 ::H5Tclose(mem_type); 902 ::H5Sclose(mem_space); 903 ::H5Sclose(file_space); 904 ::H5Dclose(dataset); 905 906 return true; 907 } 908 909 inline bool read_object(hid_t a_loc,const std: 910 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c 911 if(dataset<0) { 912 a_size = 0; 913 a_data = 0; 914 return false; 915 } 916 917 hid_t file_type = H5Dget_type(dataset); 918 if(file_type<0) { 919 ::H5Dclose(dataset); 920 a_size = 0; 921 a_data = 0; 922 return false; 923 } 924 925 H5T_class_t t_class = H5Tget_class(file_type 926 if(t_class!=H5T_COMPOUND) { 927 ::H5Tclose(file_type); 928 ::H5Dclose(dataset); 929 a_size = 0; 930 a_data = 0; 931 return false; 932 } 933 934 size_t sz = H5Tget_size(file_type); 935 if(!sz) { 936 ::H5Tclose(file_type); 937 ::H5Dclose(dataset); 938 a_size = 0; 939 a_data = 0; 940 return false; 941 } 942 943 hid_t mem_type = compound_mem_type(file_type 944 if(mem_type<0) { 945 ::H5Tclose(file_type); 946 ::H5Dclose(dataset); 947 a_size = 0; 948 a_data = 0; 949 return false; 950 } 951 952 ::H5Tclose(file_type); 953 954 hid_t dataspace = H5Dget_space(dataset); 955 if(dataspace<0) { 956 ::H5Tclose(mem_type); 957 ::H5Dclose(dataset); 958 a_size = 0; 959 a_data = 0; 960 return false; 961 } 962 963 hid_t scalar = ::H5Screate(H5S_SCALAR); 964 if(scalar<0) { 965 ::H5Sclose(dataspace); 966 ::H5Tclose(mem_type); 967 ::H5Dclose(dataset); 968 a_size = 0; 969 a_data = 0; 970 return false; 971 } 972 973 char* buffer = new char[sz]; 974 if(H5Dread(dataset,mem_type,scalar,dataspace 975 delete [] buffer; 976 ::H5Sclose(scalar); 977 ::H5Sclose(dataspace); 978 ::H5Tclose(mem_type); 979 ::H5Dclose(dataset); 980 a_size = 0; 981 a_data = 0; 982 return false; 983 } 984 985 ::H5Sclose(scalar); 986 ::H5Sclose(dataspace); 987 ::H5Tclose(mem_type); 988 ::H5Dclose(dataset); 989 990 a_size = sz; 991 a_data = buffer; 992 return true; 993 } 994 995 inline bool read_array_string(hid_t a_loc,cons 996 a_array.clear(); 997 hid_t dataset = toolx_H5Dopen(a_loc,a_name.c 998 if(dataset<0) return false; 999 1000 hid_t file_type = H5Dget_type(dataset); 1001 if(file_type<0) { 1002 ::H5Dclose(dataset); 1003 return false; 1004 } 1005 1006 H5T_class_t t_class = H5Tget_class(file_typ 1007 if(t_class!=H5T_STRING) { 1008 ::H5Tclose(file_type); 1009 ::H5Dclose(dataset); 1010 return false; 1011 } 1012 1013 size_t sz = H5Tget_size(file_type); 1014 ::H5Tclose(file_type); 1015 if(!sz) { 1016 ::H5Dclose(dataset); 1017 return false; 1018 } 1019 1020 // We could have use file_type since, for s 1021 // file type is the same than memory type. 1022 hid_t mem_type = string_datatype(sz); 1023 if(mem_type<0) { 1024 ::H5Dclose(dataset); 1025 return false; 1026 } 1027 1028 char* buffer = new char[sz]; 1029 herr_t stat = H5Dread(dataset,mem_type,H5S_ 1030 ::H5Tclose(mem_type); 1031 ::H5Dclose(dataset); 1032 if(stat<0) { 1033 delete [] buffer; 1034 return false; 1035 } 1036 1037 if(!tools::buf2strings(sz,buffer,a_array)) 1038 delete [] buffer; 1039 return false; 1040 } 1041 1042 delete [] buffer; 1043 return true; 1044 } 1045 1046 }} 1047 1048 #endif