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 <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 : virtual public fmatvec::Atom, 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
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
00111 # define FOREACHKNOWNTYPE(CTYPE, H5TYPE) \
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) \
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) \
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) \
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 Exception(getPath(), "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 Exception(getPath(), "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[]={static_cast<hsize_t>(chunkSize)};
00235 prop.setChunk(1, chunkDims);
00236 if(compression>0) prop.setDeflate(compression);
00237 DataSet dataSet=parent.createDataSet(name, memDataType, fileDataSpace, prop);
00238 setId(dataSet.getId());
00239 fmatvec::Atom::msg(fmatvec::Atom::Debug)<<"HDF5:\n"
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 Exception(getPath(), "wrong call sequence");
00246 DataSet dataSet=parent.openDataSet(name);
00247 setId(dataSet.getId());
00248
00249 DataSpace fileDataSpace=getSpace();
00250
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 fmatvec::Atom::msg(fmatvec::Atom::Debug)<<"HDF5:\n"
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
00275 H5E_auto2_t func;
00276 void* client_data;
00277 Exception::getAutoPrint(func, &client_data);
00278 Exception::dontPrint();
00279 std::string ret;
00280
00281 try {
00282 ret=SimpleAttribute<std::string>::getData(*this, "Description");
00283 }
00284 catch(AttributeIException e) {
00285 ret=std::string();
00286 }
00287
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) \
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) \
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 Exception(getPath(), "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 Exception(getPath(), "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
00344 DataSpace fileDataSpace=getSpace();
00345 fileDataSpace.getSimpleExtentDims(dims);
00346
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 fmatvec::Atom::msg(fmatvec::Atom::Warn)<<"HDF5 object with id = "<<getId()<<":\n"
00360 <<"Requested struct number is out of range, returning a dummy struct."<<std::endl;
00361 return data;
00362 }
00363
00364 hsize_t start[]={static_cast<hsize_t>(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) \
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) \
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_