00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
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
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
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);
00239 setId(dataSet.getId());
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);
00248 setId(dataSet.getId());
00249
00250 DataSpace fileDataSpace=getSpace();
00251
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
00276 H5E_auto2_t func;
00277 void* client_data;
00278 Exception::getAutoPrint(func, &client_data);
00279 Exception::dontPrint();
00280 std::string ret;
00281
00282 try {
00283 ret=SimpleAttribute<std::string>::getData(*this, "Description");
00284 }
00285 catch(AttributeIException e) {
00286 ret=std::string();
00287 }
00288
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
00345 DataSpace fileDataSpace=getSpace();
00346 fileDataSpace.getSimpleExtentDims(dims);
00347
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_