EIC code displayed by LXR

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