HDF5Serie

Project Page
/home/user/MBSimWindows/hdf5serie/hdf5serie/hdf5serie/structserie.h
00001 /* Copyright (C) 2009 Markus Friedrich
00002  *
00003  * This library is free software; you can redistribute it and/or 
00004  * modify it under the terms of the GNU Lesser General Public 
00005  * License as published by the Free Software Foundation; either 
00006  * version 2.1 of the License, or (at your option) any later version. 
00007  *  
00008  * This library is distributed in the hope that it will be useful, 
00009  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
00010  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
00011  * Lesser General Public License for more details. 
00012  *  
00013  * You should have received a copy of the GNU Lesser General Public 
00014  * License along with this library; if not, write to the Free Software 
00015  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
00016  *
00017  * Contact:
00018  *   friedrich.at.gc@googlemail.com
00019  *
00020  */
00021 
00022 #ifndef _HDF5SERIE_STRUCTSERIE_H_
00023 #define _HDF5SERIE_STRUCTSERIE_H_
00024 
00025 #include <H5Cpp.h>
00026 #include <vector>
00027 #include <string>
00028 #include <assert.h>
00029 #include <hdf5serie/simpleattribute.h>
00030 #include <cstring>
00031 #include <cstdlib>
00032 #include <iostream>
00033 #include <stdexcept>
00034 
00035 namespace H5 {
00036 
00062   template<class S>
00063   class StructSerie : public DataSet {
00064     private:
00065       CompType memDataType;
00066       DataSpace memDataSpace;
00067       hsize_t dims[1];
00068       bool firstCall;
00069       std::vector<int> structOffset;
00070     public:
00075       StructSerie();
00076 
00077 #ifdef PARSED_BY_DOXYGEN
00078 // Use this code section if doxygen is running to generate documentation.
00100       void registerMember(const S& s, const CTYPE& e, const std::string name);
00101 
00108       void registerMember(const S& s, const std::vector<CTYPE>& e, unsigned int N, const std::string name);
00109 #else
00110 // Use this code section else
00111 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00112       void registerMember(const S& s, const CTYPE& e, const std::string name);
00113 #     include "hdf5serie/knowntypes.def"
00114 #     undef FOREACHKNOWNTYPE
00115 
00116 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00117       void registerMember(const S& s, const std::vector<CTYPE>& e, unsigned int N, const std::string name);
00118 #     include "hdf5serie/knowntypes.def"
00119 #     undef FOREACHKNOWNTYPE
00120 #endif
00121 
00131       void create(const CommonFG& parent, const std::string& name, int compression=FileSerie::getDefaultCompression(), int chunkSize=FileSerie::getDefaultChunkSize());
00132 
00140       void open(const CommonFG& parent, const std::string& name);
00141 
00146       void setDescription(const std::string& desc);
00147 
00152       std::string getDescription();
00153 
00159       void append(const S& data);
00160 
00162       inline int getRows();
00163 
00165       inline unsigned int getMembers();
00166 
00171       S getRow(const int row);
00172 
00178       std::vector<std::string> getMemberLabel();
00179 
00180       void extend(const hsize_t* size);
00181   };
00182 
00183 
00184 
00185   template<class S>
00186   StructSerie<S>::StructSerie() : DataSet(), memDataType(), firstCall(true) {
00187     dims[0]=0;
00188     hsize_t memDims[]={1};
00189     memDataSpace=DataSpace(1, memDims);
00190   }
00191 
00192 # define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00193   template<class S> \
00194   void StructSerie<S>::registerMember(const S& s, const CTYPE& e, const std::string name) { \
00195     int size; \
00196     if(!firstCall) size=memDataType.getSize(); else size=0; \
00197     CompType oldMemDataType(memDataType); \
00198     memDataType=CompType(size+toH5Type(e).getSize()); \
00199     for(int i=0; i<(firstCall?0:oldMemDataType.getNmembers()); i++) \
00200       memDataType.insertMember(oldMemDataType.getMemberName(i), oldMemDataType.getMemberOffset(i), oldMemDataType.getMemberDataType(i)); \
00201     memDataType.insertMember(name, size, toH5Type(e)); \
00202     structOffset.push_back((char*)&e-(char*)&s); \
00203     firstCall=false; \
00204   }
00205 # include "hdf5serie/knowntypes.def"
00206 # undef FOREACHKNOWNTYPE
00207 
00208 # define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00209   template<class S> \
00210   void StructSerie<S>::registerMember(const S& s, const std::vector<CTYPE>& e, unsigned int N, const std::string name) { \
00211     if(e.size()!=0 && e.size()!=N) throw std::runtime_error("wrong dimension"); \
00212     int size; \
00213     if(!firstCall) size=memDataType.getSize(); else size=0; \
00214     CTYPE dummy; \
00215     hsize_t dims[]={N}; \
00216     CompType oldMemDataType(memDataType); \
00217     memDataType=CompType(size+ArrayType(toH5Type(dummy), 1, dims).getSize()); \
00218     for(int i=0; i<(firstCall?0:oldMemDataType.getNmembers()); i++) \
00219       memDataType.insertMember(oldMemDataType.getMemberName(i), oldMemDataType.getMemberOffset(i), oldMemDataType.getMemberDataType(i)); \
00220     memDataType.insertMember(name, size, ArrayType(toH5Type(dummy), 1, dims)); \
00221     structOffset.push_back((char*)&e-(char*)&s); \
00222     firstCall=false; \
00223   }
00224 # include "hdf5serie/knowntypes.def"
00225 # undef FOREACHKNOWNTYPE
00226 
00227   template<class S>
00228   void StructSerie<S>::create(const CommonFG& parent, const std::string& name, int compression, int chunkSize) {
00229     if(firstCall) throw std::runtime_error("wrong call sequence");
00230     dims[0]=0;
00231     hsize_t maxDims[]={H5S_UNLIMITED};
00232     DataSpace fileDataSpace(1, dims, maxDims);
00233     DSetCreatPropList prop;
00234     hsize_t chunkDims[]={chunkSize};
00235     prop.setChunk(1, chunkDims);
00236     if(compression>0) prop.setDeflate(compression);
00237     DataSet dataSet=parent.createDataSet(name, memDataType, fileDataSpace, prop); // increments the refcount
00238     setId(dataSet.getId()); // increment the ref count (the ctor of dataset decrements it again)
00239     //std::cout<<"INFO from HDF5:"<<std::endl
00240     //         <<"  Created object with name = "<<name<<", id = "<<getId()<<" at parent with id = "<<((Group*)&parent)->getId()<<"."<<std::endl;
00241   }
00242   
00243   template<class S>
00244   void StructSerie<S>::open(const CommonFG& parent, const std::string& name) {
00245     if(firstCall) throw std::runtime_error("wrong call sequence");
00246     DataSet dataSet=parent.openDataSet(name); // increments the refcount
00247     setId(dataSet.getId()); // increment the ref count (the ctor of dataset decrements it again)
00248   
00249     DataSpace fileDataSpace=getSpace();
00250     // Check if dataspace and datatype complies with the class
00251     assert(fileDataSpace.getSimpleExtentNdims()==1);
00252     hsize_t maxDims[1];
00253     fileDataSpace.getSimpleExtentDims(dims, maxDims);
00254     assert(maxDims[0]==H5S_UNLIMITED);
00255   
00256     assert(dataSet.getDataType().getClass()==H5T_COMPOUND);
00257     assert((int)structOffset.size()==getCompType().getNmembers());
00258     for(unsigned int i=0; i<structOffset.size(); i++) {
00259       assert(getCompType().getMemberName(i)==memDataType.getMemberName(i));
00260       assert(getCompType().getMemberOffset(i)==memDataType.getMemberOffset(i));
00261       assert(getCompType().getMemberDataType(i).getClass()==memDataType.getMemberDataType(i).getClass());
00262     }
00263     //std::cout<<"INFO from HDF5:"<<std::endl
00264     //         <<"  Opened object with name = "<<name<<", id = "<<getId()<<" at parent with id = "<<((Group*)&parent)->getId()<<"."<<std::endl;
00265   }
00266   
00267   template<class S>
00268   void StructSerie<S>::setDescription(const std::string& description) {
00269     SimpleAttribute<std::string> desc(*this, "Description", description);
00270   }
00271   
00272   template<class S>
00273   std::string StructSerie<S>::getDescription() {
00274     // save and disable c error printing
00275     H5E_auto2_t func;
00276     void* client_data;
00277     Exception::getAutoPrint(func, &client_data);
00278     Exception::dontPrint();
00279     std::string ret;
00280     // catch error if Attribute is not found
00281     try {
00282       ret=SimpleAttribute<std::string>::getData(*this, "Description");
00283     }
00284     catch(AttributeIException e) {
00285       ret=std::string();
00286     }
00287     // restore c error printing
00288     Exception::setAutoPrint(func, client_data);
00289     return ret;
00290   }
00291   
00292   template<class S>
00293   void StructSerie<S>::append(const S& data) {
00294     dims[0]++;
00295     DataSet::extend(dims);
00296   
00297     hsize_t start[]={dims[0]-1};
00298     hsize_t count[]={1};
00299     DataSpace fileDataSpace=getSpace();
00300     fileDataSpace.selectHyperslab(H5S_SELECT_SET, count, start);
00301   
00302     std::vector<char> buf(memDataType.getSize());
00303     std::list<std::vector<char> > charptr;
00304     for(int i=0; i<memDataType.getNmembers(); i++) {
00305 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00306       if(memDataType.getMemberDataType(i)==H5TYPE) \
00307         *(CTYPE*)(&buf[0]+memDataType.getMemberOffset(i))=*(CTYPE*)((char*)&data+structOffset[i]);
00308 #     include "knownpodtypes.def"
00309 #     undef FOREACHKNOWNTYPE
00310       if(memDataType.getMemberDataType(i)==StrType(PredType::C_S1, H5T_VARIABLE)) {
00311         charptr.push_back(std::vector<char>(((std::string*)((char*)&data+structOffset[i]))->size()+1));
00312         char* str=&(*--charptr.end())[0];
00313         strcpy(str, ((std::string*)((char*)&data+structOffset[i]))->c_str());
00314         *(char**)(&buf[0]+memDataType.getMemberOffset(i))=str;
00315       }
00316       if(memDataType.getMemberDataType(i).getClass()==H5T_ARRAY) {
00317         hsize_t dims[1];
00318         memDataType.getMemberArrayType(i).getArrayDims(dims);
00319 #       define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00320         if(memDataType.getMemberDataType(i)==ArrayType(H5TYPE,1,dims)) { \
00321           std::vector<CTYPE>* vec=(std::vector<CTYPE>*)((char*)&data+structOffset[i]); \
00322           if(vec->size()!=dims[0]) throw std::runtime_error("the dimension does not match"); \
00323           memcpy(&buf[0]+memDataType.getMemberOffset(i), &((*vec)[0]), dims[0]*sizeof(CTYPE)); \
00324         }
00325 #       include "knownpodtypes.def"
00326 #       undef FOREACHKNOWNTYPE
00327         if(memDataType.getMemberDataType(i)==ArrayType(StrType(PredType::C_S1, H5T_VARIABLE),1,dims))
00328           for(unsigned int j=0; j<dims[0]; j++) {
00329             std::vector<std::string>* vec=(std::vector<std::string>*)((char*)&data+structOffset[i]);
00330             if(vec->size()!=dims[0]) throw std::runtime_error("the dimension does not match");
00331             charptr.push_back(std::vector<char>((*vec)[j].size()+1));
00332             char* str=&(*--charptr.end())[0];
00333             strcpy(str, (*vec)[j].c_str());
00334             *(char**)(&buf[0]+memDataType.getMemberOffset(i)+j*sizeof(char*))=str;
00335           }
00336       }
00337     }
00338     write(&buf[0], memDataType, memDataSpace, fileDataSpace);
00339   }
00340 
00341   template<class S>
00342   int StructSerie<S>::getRows() {
00343     // get current dims from dataspace (maybe another (single-)writer process has increased the number of rows)
00344     DataSpace fileDataSpace=getSpace();
00345     fileDataSpace.getSimpleExtentDims(dims);
00346     // return current value
00347     return dims[0];
00348   }
00349   
00350   template<class S>
00351   unsigned int StructSerie<S>::getMembers() {
00352     return memDataType.getNmembers();
00353   }
00354   
00355   template<class S>
00356   S StructSerie<S>::getRow(const int row) {
00357     S data;
00358     if(row<0 || row>=(int)dims[0]) {
00359       std::cerr<<"WARNING from HDF5 object with id = "<<getId()<<":"<<std::endl
00360                <<"  Requested struct number is out of range, returning a dummy struct."<<std::endl;
00361       return data;
00362     }
00363 
00364     hsize_t start[]={row};
00365     hsize_t count[]={1};
00366     DataSpace fileDataSpace=getSpace();
00367     fileDataSpace.selectHyperslab(H5S_SELECT_SET, count, start);
00368     
00369     std::vector<char> buf(memDataType.getSize());
00370     read(&buf[0], memDataType, memDataSpace, fileDataSpace);
00371     for(int i=0; i<memDataType.getNmembers(); i++) {
00372 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00373       if(memDataType.getMemberDataType(i)==H5TYPE) \
00374         *(CTYPE*)((char*)&data+structOffset[i])=*(CTYPE*)(&buf[0]+memDataType.getMemberOffset(i));
00375 #     include "knownpodtypes.def"
00376 #     undef FOREACHKNOWNTYPE
00377       if(memDataType.getMemberDataType(i)==StrType(PredType::C_S1, H5T_VARIABLE)) {
00378         char* str=*(char**)(&buf[0]+memDataType.getMemberOffset(i));
00379         *((std::string*)((char*)&data+structOffset[i]))=str;
00380         free(str);
00381       }
00382       if(memDataType.getMemberDataType(i).getClass()==H5T_ARRAY) {
00383         hsize_t dims[1];
00384         memDataType.getMemberArrayType(i).getArrayDims(dims);
00385 #       define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00386         if(memDataType.getMemberDataType(i)==ArrayType(H5TYPE,1,dims)) { \
00387           std::vector<CTYPE>* vec=(std::vector<CTYPE>*)((char*)&data+structOffset[i]); \
00388           vec->resize(dims[0]); \
00389           memcpy(&((*vec)[0]), &buf[0]+memDataType.getMemberOffset(i), dims[0]*sizeof(CTYPE)); \
00390         }
00391 #       include "knownpodtypes.def"
00392 #       undef FOREACHKNOWNTYPE
00393         if(memDataType.getMemberDataType(i)==ArrayType(StrType(PredType::C_S1, H5T_VARIABLE),1,dims)) {
00394           std::vector<std::string>* vec=(std::vector<std::string>*)((char*)&data+structOffset[i]);
00395           vec->resize(dims[0]);
00396           for(unsigned int j=0; j<dims[0]; j++) {
00397             char* str=*(char**)(&buf[0]+memDataType.getMemberOffset(i)+j*sizeof(char*));
00398             (*vec)[j]=str;
00399             free(str);
00400           }
00401         }
00402       }
00403     }
00404     return data;
00405   }
00406   
00407   template<class S>
00408   std::vector<std::string> StructSerie<S>::getMemberLabel() {
00409     std::vector<std::string> ret;
00410     for(int i=0; i<memDataType.getNmembers(); i++)
00411       ret.push_back(memDataType.getMemberName(i));
00412     return ret;
00413   }
00414   
00415   template<class S>
00416   void StructSerie<S>::extend(const hsize_t* size) {
00417     assert(1);
00418   }
00419 
00420 }
00421 
00422 #endif // _TIMESERIE_H_