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 <fmatvec/atom.h>
00026 #include <H5Cpp.h>
00027 #include <vector>
00028 #include <string>
00029 #include <assert.h>
00030 #include <hdf5serie/simpleattribute.h>
00031 #include <cstring>
00032 #include <cstdlib>
00033 #include <iostream>
00034 #include <stdexcept>
00035 
00036 namespace H5 {
00037 
00063   template<class S>
00064   class StructSerie : public DataSet {
00065     private:
00066       CompType memDataType;
00067       DataSpace memDataSpace;
00068       hsize_t dims[1];
00069       bool firstCall;
00070       std::vector<int> structOffset;
00071     public:
00076       StructSerie();
00077 
00078 #ifdef PARSED_BY_DOXYGEN
00079 // Use this code section if doxygen is running to generate documentation.
00101       void registerMember(const S& s, const CTYPE& e, const std::string name);
00102 
00109       void registerMember(const S& s, const std::vector<CTYPE>& e, unsigned int N, const std::string name);
00110 #else
00111 // Use this code section else
00112 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00113       void registerMember(const S& s, const CTYPE& e, const std::string name);
00114 #     include "hdf5serie/knowntypes.def"
00115 #     undef FOREACHKNOWNTYPE
00116 
00117 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00118       void registerMember(const S& s, const std::vector<CTYPE>& e, unsigned int N, const std::string name);
00119 #     include "hdf5serie/knowntypes.def"
00120 #     undef FOREACHKNOWNTYPE
00121 #endif
00122 
00132       void create(const CommonFG& parent, const std::string& name, int compression=FileSerie::getDefaultCompression(), int chunkSize=FileSerie::getDefaultChunkSize());
00133 
00141       void open(const CommonFG& parent, const std::string& name);
00142 
00147       void setDescription(const std::string& desc);
00148 
00153       std::string getDescription();
00154 
00160       void append(const S& data);
00161 
00163       inline int getRows();
00164 
00166       inline unsigned int getMembers();
00167 
00172       S getRow(const int row);
00173 
00179       std::vector<std::string> getMemberLabel();
00180 
00181       void extend(const hsize_t* size);
00182   };
00183 
00184 
00185 
00186   template<class S>
00187   StructSerie<S>::StructSerie() : DataSet(), memDataType(), firstCall(true) {
00188     dims[0]=0;
00189     hsize_t memDims[]={1};
00190     memDataSpace=DataSpace(1, memDims);
00191   }
00192 
00193 # define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00194   template<class S> \
00195   void StructSerie<S>::registerMember(const S& s, const CTYPE& e, const std::string name) { \
00196     int size; \
00197     if(!firstCall) size=memDataType.getSize(); else size=0; \
00198     CompType oldMemDataType(memDataType); \
00199     memDataType=CompType(size+toH5Type(e).getSize()); \
00200     for(int i=0; i<(firstCall?0:oldMemDataType.getNmembers()); i++) \
00201       memDataType.insertMember(oldMemDataType.getMemberName(i), oldMemDataType.getMemberOffset(i), oldMemDataType.getMemberDataType(i)); \
00202     memDataType.insertMember(name, size, toH5Type(e)); \
00203     structOffset.push_back((char*)&e-(char*)&s); \
00204     firstCall=false; \
00205   }
00206 # include "hdf5serie/knowntypes.def"
00207 # undef FOREACHKNOWNTYPE
00208 
00209 # define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00210   template<class S> \
00211   void StructSerie<S>::registerMember(const S& s, const std::vector<CTYPE>& e, unsigned int N, const std::string name) { \
00212     if(e.size()!=0 && e.size()!=N) throw std::runtime_error("wrong dimension"); \
00213     int size; \
00214     if(!firstCall) size=memDataType.getSize(); else size=0; \
00215     CTYPE dummy; \
00216     hsize_t dims[]={N}; \
00217     CompType oldMemDataType(memDataType); \
00218     memDataType=CompType(size+ArrayType(toH5Type(dummy), 1, dims).getSize()); \
00219     for(int i=0; i<(firstCall?0:oldMemDataType.getNmembers()); i++) \
00220       memDataType.insertMember(oldMemDataType.getMemberName(i), oldMemDataType.getMemberOffset(i), oldMemDataType.getMemberDataType(i)); \
00221     memDataType.insertMember(name, size, ArrayType(toH5Type(dummy), 1, dims)); \
00222     structOffset.push_back((char*)&e-(char*)&s); \
00223     firstCall=false; \
00224   }
00225 # include "hdf5serie/knowntypes.def"
00226 # undef FOREACHKNOWNTYPE
00227 
00228   template<class S>
00229   void StructSerie<S>::create(const CommonFG& parent, const std::string& name, int compression, int chunkSize) {
00230     if(firstCall) throw std::runtime_error("wrong call sequence");
00231     dims[0]=0;
00232     hsize_t maxDims[]={H5S_UNLIMITED};
00233     DataSpace fileDataSpace(1, dims, maxDims);
00234     DSetCreatPropList prop;
00235     hsize_t chunkDims[]={chunkSize};
00236     prop.setChunk(1, chunkDims);
00237     if(compression>0) prop.setDeflate(compression);
00238     DataSet dataSet=parent.createDataSet(name, memDataType, fileDataSpace, prop); // increments the refcount
00239     setId(dataSet.getId()); // increment the ref count (the ctor of dataset decrements it again)
00240     fmatvec::Atom::msg(fmatvec::Atom::Debug)<<"HDF5:\n"
00241       <<"Created object with name = "<<name<<", id = "<<getId()<<" at parent with id = "<<((Group*)&parent)->getId()<<"."<<std::endl;
00242   }
00243   
00244   template<class S>
00245   void StructSerie<S>::open(const CommonFG& parent, const std::string& name) {
00246     if(firstCall) throw std::runtime_error("wrong call sequence");
00247     DataSet dataSet=parent.openDataSet(name); // increments the refcount
00248     setId(dataSet.getId()); // increment the ref count (the ctor of dataset decrements it again)
00249   
00250     DataSpace fileDataSpace=getSpace();
00251     // Check if dataspace and datatype complies with the class
00252     assert(fileDataSpace.getSimpleExtentNdims()==1);
00253     hsize_t maxDims[1];
00254     fileDataSpace.getSimpleExtentDims(dims, maxDims);
00255     assert(maxDims[0]==H5S_UNLIMITED);
00256   
00257     assert(dataSet.getDataType().getClass()==H5T_COMPOUND);
00258     assert((int)structOffset.size()==getCompType().getNmembers());
00259     for(unsigned int i=0; i<structOffset.size(); i++) {
00260       assert(getCompType().getMemberName(i)==memDataType.getMemberName(i));
00261       assert(getCompType().getMemberOffset(i)==memDataType.getMemberOffset(i));
00262       assert(getCompType().getMemberDataType(i).getClass()==memDataType.getMemberDataType(i).getClass());
00263     }
00264     fmatvec::Atom::msg(fmatvec::Atom::Debug)<<"HDF5:\n"
00265       <<"Opened object with name = "<<name<<", id = "<<getId()<<" at parent with id = "<<((Group*)&parent)->getId()<<"."<<std::endl;
00266   }
00267   
00268   template<class S>
00269   void StructSerie<S>::setDescription(const std::string& description) {
00270     SimpleAttribute<std::string> desc(*this, "Description", description);
00271   }
00272   
00273   template<class S>
00274   std::string StructSerie<S>::getDescription() {
00275     // save and disable c error printing
00276     H5E_auto2_t func;
00277     void* client_data;
00278     Exception::getAutoPrint(func, &client_data);
00279     Exception::dontPrint();
00280     std::string ret;
00281     // catch error if Attribute is not found
00282     try {
00283       ret=SimpleAttribute<std::string>::getData(*this, "Description");
00284     }
00285     catch(AttributeIException e) {
00286       ret=std::string();
00287     }
00288     // restore c error printing
00289     Exception::setAutoPrint(func, client_data);
00290     return ret;
00291   }
00292   
00293   template<class S>
00294   void StructSerie<S>::append(const S& data) {
00295     dims[0]++;
00296     DataSet::extend(dims);
00297   
00298     hsize_t start[]={dims[0]-1};
00299     hsize_t count[]={1};
00300     DataSpace fileDataSpace=getSpace();
00301     fileDataSpace.selectHyperslab(H5S_SELECT_SET, count, start);
00302   
00303     std::vector<char> buf(memDataType.getSize());
00304     std::list<std::vector<char> > charptr;
00305     for(int i=0; i<memDataType.getNmembers(); i++) {
00306 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00307       if(memDataType.getMemberDataType(i)==H5TYPE) \
00308         *(CTYPE*)(&buf[0]+memDataType.getMemberOffset(i))=*(CTYPE*)((char*)&data+structOffset[i]);
00309 #     include "knownpodtypes.def"
00310 #     undef FOREACHKNOWNTYPE
00311       if(memDataType.getMemberDataType(i)==StrType(PredType::C_S1, H5T_VARIABLE)) {
00312         charptr.push_back(std::vector<char>(((std::string*)((char*)&data+structOffset[i]))->size()+1));
00313         char* str=&(*--charptr.end())[0];
00314         strcpy(str, ((std::string*)((char*)&data+structOffset[i]))->c_str());
00315         *(char**)(&buf[0]+memDataType.getMemberOffset(i))=str;
00316       }
00317       if(memDataType.getMemberDataType(i).getClass()==H5T_ARRAY) {
00318         hsize_t dims[1];
00319         memDataType.getMemberArrayType(i).getArrayDims(dims);
00320 #       define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00321         if(memDataType.getMemberDataType(i)==ArrayType(H5TYPE,1,dims)) { \
00322           std::vector<CTYPE>* vec=(std::vector<CTYPE>*)((char*)&data+structOffset[i]); \
00323           if(vec->size()!=dims[0]) throw std::runtime_error("the dimension does not match"); \
00324           memcpy(&buf[0]+memDataType.getMemberOffset(i), &((*vec)[0]), dims[0]*sizeof(CTYPE)); \
00325         }
00326 #       include "knownpodtypes.def"
00327 #       undef FOREACHKNOWNTYPE
00328         if(memDataType.getMemberDataType(i)==ArrayType(StrType(PredType::C_S1, H5T_VARIABLE),1,dims))
00329           for(unsigned int j=0; j<dims[0]; j++) {
00330             std::vector<std::string>* vec=(std::vector<std::string>*)((char*)&data+structOffset[i]);
00331             if(vec->size()!=dims[0]) throw std::runtime_error("the dimension does not match");
00332             charptr.push_back(std::vector<char>((*vec)[j].size()+1));
00333             char* str=&(*--charptr.end())[0];
00334             strcpy(str, (*vec)[j].c_str());
00335             *(char**)(&buf[0]+memDataType.getMemberOffset(i)+j*sizeof(char*))=str;
00336           }
00337       }
00338     }
00339     write(&buf[0], memDataType, memDataSpace, fileDataSpace);
00340   }
00341 
00342   template<class S>
00343   int StructSerie<S>::getRows() {
00344     // get current dims from dataspace (maybe another (single-)writer process has increased the number of rows)
00345     DataSpace fileDataSpace=getSpace();
00346     fileDataSpace.getSimpleExtentDims(dims);
00347     // return current value
00348     return dims[0];
00349   }
00350   
00351   template<class S>
00352   unsigned int StructSerie<S>::getMembers() {
00353     return memDataType.getNmembers();
00354   }
00355   
00356   template<class S>
00357   S StructSerie<S>::getRow(const int row) {
00358     S data;
00359     if(row<0 || row>=(int)dims[0]) {
00360       fmatvec::Atom::msg(fmatvec::Atom::Warn)<<"HDF5 object with id = "<<getId()<<":\n"
00361                                              <<"Requested struct number is out of range, returning a dummy struct."<<std::endl;
00362       return data;
00363     }
00364 
00365     hsize_t start[]={row};
00366     hsize_t count[]={1};
00367     DataSpace fileDataSpace=getSpace();
00368     fileDataSpace.selectHyperslab(H5S_SELECT_SET, count, start);
00369     
00370     std::vector<char> buf(memDataType.getSize());
00371     read(&buf[0], memDataType, memDataSpace, fileDataSpace);
00372     for(int i=0; i<memDataType.getNmembers(); i++) {
00373 #     define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00374       if(memDataType.getMemberDataType(i)==H5TYPE) \
00375         *(CTYPE*)((char*)&data+structOffset[i])=*(CTYPE*)(&buf[0]+memDataType.getMemberOffset(i));
00376 #     include "knownpodtypes.def"
00377 #     undef FOREACHKNOWNTYPE
00378       if(memDataType.getMemberDataType(i)==StrType(PredType::C_S1, H5T_VARIABLE)) {
00379         char* str=*(char**)(&buf[0]+memDataType.getMemberOffset(i));
00380         *((std::string*)((char*)&data+structOffset[i]))=str;
00381         free(str);
00382       }
00383       if(memDataType.getMemberDataType(i).getClass()==H5T_ARRAY) {
00384         hsize_t dims[1];
00385         memDataType.getMemberArrayType(i).getArrayDims(dims);
00386 #       define FOREACHKNOWNTYPE(CTYPE, H5TYPE, TYPE) \
00387         if(memDataType.getMemberDataType(i)==ArrayType(H5TYPE,1,dims)) { \
00388           std::vector<CTYPE>* vec=(std::vector<CTYPE>*)((char*)&data+structOffset[i]); \
00389           vec->resize(dims[0]); \
00390           memcpy(&((*vec)[0]), &buf[0]+memDataType.getMemberOffset(i), dims[0]*sizeof(CTYPE)); \
00391         }
00392 #       include "knownpodtypes.def"
00393 #       undef FOREACHKNOWNTYPE
00394         if(memDataType.getMemberDataType(i)==ArrayType(StrType(PredType::C_S1, H5T_VARIABLE),1,dims)) {
00395           std::vector<std::string>* vec=(std::vector<std::string>*)((char*)&data+structOffset[i]);
00396           vec->resize(dims[0]);
00397           for(unsigned int j=0; j<dims[0]; j++) {
00398             char* str=*(char**)(&buf[0]+memDataType.getMemberOffset(i)+j*sizeof(char*));
00399             (*vec)[j]=str;
00400             free(str);
00401           }
00402         }
00403       }
00404     }
00405     return data;
00406   }
00407   
00408   template<class S>
00409   std::vector<std::string> StructSerie<S>::getMemberLabel() {
00410     std::vector<std::string> ret;
00411     for(int i=0; i<memDataType.getNmembers(); i++)
00412       ret.push_back(memDataType.getMemberName(i));
00413     return ret;
00414   }
00415   
00416   template<class S>
00417   void StructSerie<S>::extend(const hsize_t* size) {
00418     assert(1);
00419   }
00420 
00421 }
00422 
00423 #endif // _TIMESERIE_H_