SHOGUN v0.9.0
|
00001 /* 00002 * This program is free software; you can redistribute it and/or modify 00003 * it under the terms of the GNU General Public License as published by 00004 * the Free Software Foundation; either version 3 of the License, or 00005 * (at your option) any later version. 00006 * 00007 * Written (W) 2010 Soeren Sonnenburg 00008 * Copyright (C) 2010 Berlin Institute of Technology 00009 */ 00010 00011 #include "lib/config.h" 00012 #ifdef HAVE_HDF5 00013 00014 #include "lib/SerializableHdf5File.h" 00015 #include "lib/SerializableHdf5Reader00.h" 00016 00017 #define NOT_OPEN ((hid_t) -1) 00018 00019 #define STR_KEY_FILETYPE "filetype" 00020 #define STR_FILETYPE_00 \ 00021 "_SHOGUN_SERIALIZABLE_HDF5_FILE_V_00_" 00022 00023 using namespace shogun; 00024 00025 CSerializableHdf5File::type_item_t::type_item_t(const char* name_) 00026 { 00027 rank = 0; 00028 dims[0] = dims[1] = 0; 00029 dspace = dtype = dset = NOT_OPEN; 00030 vltype = NULL; 00031 y = x = sub_y = 0; 00032 sparse_ptr = NULL; 00033 name = name_; 00034 } 00035 00036 CSerializableHdf5File::type_item_t::~type_item_t(void) 00037 { 00038 if (dset >= 0) H5Dclose(dset); 00039 if (dtype >= 0) H5Tclose(dtype); 00040 if (dspace >= 0) H5Sclose(dspace); 00041 if (vltype != NULL) delete[] vltype; 00042 /* Do not delete SPARSE_PTR */ 00043 } 00044 00045 hid_t 00046 CSerializableHdf5File::sizeof_sparsetype(void) { 00047 return H5Tget_size(TYPE_INDEX) + H5Tget_size(H5T_STD_REF_OBJ); 00048 } 00049 hid_t 00050 CSerializableHdf5File::new_sparsetype(void) 00051 { 00052 hid_t result = H5Tcreate(H5T_COMPOUND, sizeof_sparsetype()); 00053 00054 if (H5Tinsert(result, STR_SPARSE_VINDEX, 0, TYPE_INDEX) < 0) 00055 return NOT_OPEN; 00056 if (H5Tinsert(result, STR_SPARSE_FPTR, H5Tget_size(TYPE_INDEX), 00057 H5T_STD_REF_OBJ) < 0) 00058 return NOT_OPEN; 00059 00060 return result; 00061 } 00062 hobj_ref_t* 00063 CSerializableHdf5File::get_ref_sparstype(void* sparse_buf) { 00064 return (hobj_ref_t*) 00065 ((char*) sparse_buf + H5Tget_size(TYPE_INDEX)); 00066 } 00067 00068 hid_t 00069 CSerializableHdf5File::new_sparseentrytype(EPrimitiveType ptype) 00070 { 00071 hid_t result = H5Tcreate(H5T_COMPOUND, 00072 TSGDataType::sizeof_sparseentry(ptype)); 00073 if (result < 0) return NOT_OPEN; 00074 00075 if (H5Tinsert(result, STR_SPARSEENTRY_FINDEX, 00076 HOFFSET(TSparseEntry<char>, feat_index), TYPE_INDEX) 00077 < 0) return NOT_OPEN; 00078 if (H5Tinsert(result, STR_SPARSEENTRY_ENTRY, TSGDataType 00079 ::offset_sparseentry(ptype), 00080 ptype2hdf5(ptype)) < 0) return NOT_OPEN; 00081 00082 return result; 00083 } 00084 00085 hid_t 00086 CSerializableHdf5File::ptype2hdf5(EPrimitiveType ptype) 00087 { 00088 switch (ptype) { 00089 case PT_BOOL: 00090 switch (sizeof (bool)) { 00091 case 1: return H5T_NATIVE_UINT8; 00092 case 2: return H5T_NATIVE_UINT16; 00093 case 4: return H5T_NATIVE_UINT32; 00094 case 8: return H5T_NATIVE_UINT64; 00095 default: break; 00096 } 00097 break; 00098 case PT_CHAR: return H5T_NATIVE_CHAR; break; 00099 case PT_INT8: return H5T_NATIVE_INT8; break; 00100 case PT_UINT8: return H5T_NATIVE_UINT8; break; 00101 case PT_INT16: return H5T_NATIVE_INT16; break; 00102 case PT_UINT16: return H5T_NATIVE_UINT16; break; 00103 case PT_INT32: return H5T_NATIVE_INT32; break; 00104 case PT_UINT32: return H5T_NATIVE_UINT32; break; 00105 case PT_INT64: return H5T_NATIVE_INT64; break; 00106 case PT_UINT64: return H5T_NATIVE_UINT64; break; 00107 case PT_FLOAT32: return H5T_NATIVE_FLOAT; break; 00108 case PT_FLOAT64: return H5T_NATIVE_DOUBLE; break; 00109 case PT_FLOATMAX: return H5T_NATIVE_LDOUBLE; break; 00110 case PT_SGOBJECT: return NOT_OPEN; break; 00111 } 00112 00113 return NOT_OPEN; 00114 } 00115 00116 hid_t 00117 CSerializableHdf5File::new_stype2hdf5(EStructType stype, 00118 EPrimitiveType ptype) 00119 { 00120 hid_t result = ptype2hdf5(ptype); 00121 00122 switch (stype) { 00123 case ST_NONE: result = H5Tcopy(result); break; 00124 case ST_STRING: result = H5Tvlen_create(result); break; 00125 case ST_SPARSE: result = new_sparsetype(); break; 00126 } 00127 00128 return result; 00129 } 00130 00131 bool 00132 CSerializableHdf5File::index2string( 00133 char* dest, size_t n, EContainerType ctype, index_t y, index_t x) 00134 { 00135 switch (ctype) { 00136 case CT_SCALAR: return false; 00137 case CT_VECTOR: snprintf(dest, n, "y%u", y); break; 00138 case CT_MATRIX: snprintf(dest, n, "y%u_x%u", y, x); break; 00139 } 00140 00141 return true; 00142 } 00143 00144 bool 00145 CSerializableHdf5File::isequal_stype2hdf5(EStructType stype, 00146 EPrimitiveType ptype, 00147 hid_t htype) 00148 { 00149 hid_t pbuf = ptype2hdf5(ptype), pbuf2 = NOT_OPEN; 00150 00151 bool to_close = false; 00152 switch (stype) { 00153 case ST_NONE: break; 00154 case ST_STRING: 00155 to_close = true; pbuf = H5Tvlen_create(pbuf); break; 00156 case ST_SPARSE: 00157 to_close = true; pbuf = new_sparsetype(); 00158 pbuf2 = new_sparseentrytype(ptype); break; 00159 } 00160 00161 bool result = (H5Tequal(htype, pbuf) > 0) 00162 || (pbuf2 >= 0 && H5Tequal(htype, pbuf2) > 0); 00163 00164 if (pbuf2 >= 0 && H5Tclose(pbuf2) < 0) return false; 00165 if (to_close && H5Tclose(pbuf) < 0) return false; 00166 return result; 00167 } 00168 00169 bool 00170 CSerializableHdf5File::dspace_select(EContainerType ctype, index_t y, 00171 index_t x) 00172 { 00173 type_item_t* m = m_stack_type.back(); 00174 00175 if (H5Sselect_none(m->dspace) < 0) return false; 00176 00177 hsize_t coord[2]; 00178 switch (ctype) { 00179 case CT_SCALAR: return false; 00180 case CT_MATRIX: coord[1] = x; /* break; */ 00181 case CT_VECTOR: coord[0] = y; break; 00182 } 00183 if (H5Sselect_elements(m->dspace, H5S_SELECT_SET, 1, coord) < 0) 00184 return false; 00185 00186 return true; 00187 } 00188 00189 bool 00190 CSerializableHdf5File::attr_write_scalar( 00191 hid_t datatype, const char* name, const void* val) 00192 { 00193 hid_t dspace; 00194 if ((dspace = H5Screate_simple(0, NULL, NULL)) < 0) return false; 00195 hid_t dtype; 00196 if ((dtype = H5Tcopy(datatype)) < 0) return false; 00197 hid_t attr; 00198 if ((attr = H5Acreate2( 00199 m_stack_h5stream.back(), name, dtype, dspace, 00200 H5P_DEFAULT, H5P_DEFAULT)) < 0) return false; 00201 00202 if (H5Awrite(attr, datatype, val) < 0) return false; 00203 00204 if (H5Aclose(attr) < 0) return false; 00205 if (H5Tclose(dtype) < 0) return false; 00206 if (H5Sclose(dspace) < 0) return false; 00207 00208 return true; 00209 } 00210 00211 bool 00212 CSerializableHdf5File::attr_write_string( 00213 const char* name, const char* val) 00214 { 00215 hid_t dtype; 00216 if ((dtype = H5Tcopy(H5T_C_S1)) < 0) return false; 00217 if (H5Tset_size(dtype, strlen(val)+1) < 0) return false; 00218 00219 if (!attr_write_scalar(dtype, name, val)) return false; 00220 00221 if (H5Tclose(dtype) < 0) return false; 00222 00223 return true; 00224 } 00225 00226 bool 00227 CSerializableHdf5File::attr_exists(const char* name) 00228 { 00229 return H5Aexists(m_stack_h5stream.back(), name) > 0; 00230 } 00231 00232 size_t 00233 CSerializableHdf5File::attr_get_size(const char* name) 00234 { 00235 if (!attr_exists(name)) return 0; 00236 00237 hid_t attr; 00238 if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT)) 00239 < 0) return 0; 00240 00241 hid_t dtype; 00242 if ((dtype = H5Aget_type(attr)) < 0) return 0; 00243 00244 size_t result = H5Tget_size(dtype); 00245 00246 if (H5Tclose(dtype) < 0) return 0; 00247 if (H5Aclose(attr) < 0) return 0; 00248 00249 return result; 00250 } 00251 00252 bool 00253 CSerializableHdf5File::attr_read_scalar( 00254 hid_t datatype, const char* name, void* val) 00255 { 00256 if (!attr_exists(name)) return false; 00257 00258 hid_t attr; 00259 if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT)) 00260 < 0) return false; 00261 00262 hid_t dspace; 00263 if ((dspace = H5Aget_space(attr)) < 0) return false; 00264 if (H5Sget_simple_extent_type(dspace) != H5S_SCALAR) return false; 00265 00266 hid_t dtype; 00267 if ((dtype = H5Aget_type(attr)) < 0) return false; 00268 if (H5Tequal(datatype, dtype) <= 0) return false; 00269 00270 if (H5Aread(attr, datatype, val) < 0) return false; 00271 00272 if (H5Tclose(dtype) < 0) return false; 00273 if (H5Sclose(dspace) < 0) return false; 00274 if (H5Aclose(attr) < 0) return false; 00275 00276 return true; 00277 } 00278 00279 bool 00280 CSerializableHdf5File::attr_read_string( 00281 const char* name, char* val, size_t n) 00282 { 00283 size_t size = attr_get_size(name); 00284 if (size == 0 || size > n) return false; 00285 00286 hid_t dtype; 00287 if ((dtype = H5Tcopy(H5T_C_S1)) < 0) return false; 00288 if (H5Tset_size(dtype, size) < 0) return false; 00289 00290 if (!attr_read_scalar(dtype, name, val)) return false; 00291 00292 if (H5Tclose(dtype) < 0) return false; 00293 00294 return true; 00295 } 00296 00297 bool 00298 CSerializableHdf5File::group_create(const char* name, 00299 const char* prefix) 00300 { 00301 hid_t ngroup; 00302 string_t gname; 00303 00304 snprintf(gname, STRING_LEN, "%s%s", prefix, name); 00305 00306 m_stack_h5stream.push_back( 00307 ngroup = H5Gcreate2(m_stack_h5stream.back(), gname, H5P_DEFAULT, 00308 H5P_DEFAULT, H5P_DEFAULT)); 00309 if (ngroup < 0) return false; 00310 00311 return true; 00312 } 00313 00314 bool 00315 CSerializableHdf5File::group_open(const char* name, 00316 const char* prefix) 00317 { 00318 hid_t group; 00319 string_t gname; 00320 00321 snprintf(gname, STRING_LEN, "%s%s", prefix, name); 00322 00323 m_stack_h5stream.push_back( 00324 group = H5Gopen2(m_stack_h5stream.back(), gname, H5P_DEFAULT)); 00325 if (group < 0) return false; 00326 00327 return true; 00328 } 00329 00330 bool 00331 CSerializableHdf5File::group_close(void) 00332 { 00333 if (H5Gclose(m_stack_h5stream.back()) < 0) return false; 00334 m_stack_h5stream.pop_back(); 00335 00336 return true; 00337 } 00338 00339 CSerializableHdf5File::CSerializableHdf5File(void) 00340 :CSerializableFile() { init(""); } 00341 00342 CSerializableHdf5File::CSerializableHdf5File(const char* fname, char rw) 00343 :CSerializableFile() 00344 { 00345 CSerializableFile::init(NULL, rw, fname); 00346 init(fname); 00347 } 00348 00349 CSerializableHdf5File::~CSerializableHdf5File() 00350 { 00351 while (m_stack_type.get_num_elements() > 0) { 00352 delete m_stack_type.back(); m_stack_type.pop_back(); 00353 } 00354 00355 close(); 00356 } 00357 00358 CSerializableFile::TSerializableReader* 00359 CSerializableHdf5File::new_reader(char* dest_version, size_t n) 00360 { 00361 if (!attr_read_string(STR_KEY_FILETYPE, dest_version, n)) 00362 return NULL; 00363 00364 if (strcmp(STR_FILETYPE_00, dest_version) == 0) 00365 return new SerializableHdf5Reader00(this); 00366 00367 return NULL; 00368 } 00369 00370 void 00371 CSerializableHdf5File::init(const char* fname) 00372 { 00373 if (m_filename == NULL || *m_filename == '\0') { 00374 SG_WARNING("Filename not given for opening file!\n"); 00375 close(); return; 00376 } 00377 00378 hid_t h5stream = NOT_OPEN; 00379 switch (m_task) { 00380 case 'w': 00381 h5stream = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, 00382 H5P_DEFAULT); 00383 break; 00384 case 'r': 00385 h5stream = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT); 00386 break; 00387 default: 00388 SG_WARNING("Could not open file `%s', unknown mode!\n", 00389 m_filename); 00390 close(); return; 00391 } 00392 00393 if (h5stream < 0) { 00394 SG_WARNING("Could not open file `%s'!\n", m_filename); 00395 close(); return; 00396 } 00397 00398 m_stack_h5stream.push_back(h5stream); 00399 switch (m_task) { 00400 case 'w': 00401 if (!attr_write_string(STR_KEY_FILETYPE, STR_FILETYPE_00)) { 00402 SG_WARNING("%s: Could not open file for writing during " 00403 "writing filetype!\n", fname); 00404 close(); return; 00405 } 00406 break; 00407 case 'r': break; 00408 default: break; 00409 } 00410 } 00411 00412 void 00413 CSerializableHdf5File::close(void) 00414 { 00415 while (m_stack_h5stream.get_num_elements() > 1) { 00416 if (m_stack_h5stream.back() >= 0) 00417 H5Gclose(m_stack_h5stream.back()); 00418 m_stack_h5stream.pop_back(); 00419 } 00420 00421 if (m_stack_h5stream.get_num_elements() == 1) { 00422 if (m_stack_h5stream.back() >= 0) 00423 H5Fclose(m_stack_h5stream.back()); 00424 m_stack_h5stream.pop_back(); 00425 } 00426 } 00427 00428 bool 00429 CSerializableHdf5File::is_opened(void) 00430 { 00431 return m_stack_h5stream.get_num_elements() > 0; 00432 } 00433 00434 bool 00435 CSerializableHdf5File::write_scalar_wrapped( 00436 const TSGDataType* type, const void* param) 00437 { 00438 type_item_t* m = m_stack_type.back(); 00439 00440 switch (type->m_stype) { 00441 case ST_NONE: 00442 if (m->y != 0 || m->x != 0) return true; 00443 break; 00444 case ST_STRING: 00445 if (m->sub_y == 0) 00446 m->vltype[m->x*m->dims[1] + m->y].p = (void*) param; 00447 00448 if ((m->sub_y 00449 < (index_t) m->vltype[m->x*m->dims[1] + m->y].len-1) 00450 || (type->m_ctype == CT_VECTOR && m->y 00451 < (index_t) m->dims[0]-1) 00452 || (type->m_ctype == CT_MATRIX 00453 && (m->x < (index_t) m->dims[0]-1 00454 || m->y < (index_t) m->dims[1]-1))) 00455 return true; 00456 break; 00457 case ST_SPARSE: 00458 if (m->sub_y != 0) return true; 00459 break; 00460 } 00461 00462 hid_t mem_type_id; 00463 if ((mem_type_id = new_stype2hdf5(type->m_stype, type->m_ptype) 00464 ) < 0) return false; 00465 00466 switch (type->m_stype) { 00467 case ST_NONE: 00468 if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL, 00469 H5P_DEFAULT, param) < 0) return false; 00470 break; 00471 case ST_STRING: 00472 if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL, 00473 H5P_DEFAULT, m->vltype) < 0) return false; 00474 break; 00475 case ST_SPARSE: 00476 if (H5Dwrite(m->dset, m->dtype, H5S_ALL, H5S_ALL, 00477 H5P_DEFAULT, m->sparse_ptr) < 0) return false; 00478 break; 00479 } 00480 00481 if (H5Tclose(mem_type_id) < 0) return false; 00482 00483 return true; 00484 } 00485 00486 bool 00487 CSerializableHdf5File::write_cont_begin_wrapped( 00488 const TSGDataType* type, index_t len_real_y, index_t len_real_x) 00489 { 00490 hbool_t bool_buf = true; 00491 00492 if (type->m_ptype != PT_SGOBJECT) return true; 00493 00494 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_CONT, &bool_buf)) 00495 return false; 00496 00497 string_t ctype_buf; 00498 type->to_string(ctype_buf, STRING_LEN); 00499 if (!attr_write_string(STR_CTYPE_NAME, ctype_buf)) return false; 00500 00501 switch (type->m_ctype) { 00502 case CT_SCALAR: 00503 SG_ERROR("write_cont_begin_wrapped(): Implementation error " 00504 "during writing Hdf5File!"); 00505 return false; 00506 case CT_MATRIX: 00507 if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_X, &len_real_x)) 00508 return false; 00509 /* break; */ 00510 case CT_VECTOR: 00511 if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_Y, &len_real_y)) 00512 return false; 00513 break; 00514 } 00515 00516 return true; 00517 } 00518 00519 bool 00520 CSerializableHdf5File::write_cont_end_wrapped( 00521 const TSGDataType* type, index_t len_real_y, index_t len_real_x) 00522 { 00523 return true; 00524 } 00525 00526 bool 00527 CSerializableHdf5File::write_string_begin_wrapped( 00528 const TSGDataType* type, index_t length) 00529 { 00530 type_item_t* m = m_stack_type.back(); 00531 00532 m->vltype[m->x*m->dims[1] + m->y].len = length; 00533 00534 return true; 00535 } 00536 00537 bool 00538 CSerializableHdf5File::write_string_end_wrapped( 00539 const TSGDataType* type, index_t length) 00540 { 00541 return true; 00542 } 00543 00544 bool 00545 CSerializableHdf5File::write_stringentry_begin_wrapped( 00546 const TSGDataType* type, index_t y) 00547 { 00548 type_item_t* m = m_stack_type.back(); 00549 00550 m->sub_y = y; 00551 00552 return true; 00553 } 00554 00555 bool 00556 CSerializableHdf5File::write_stringentry_end_wrapped( 00557 const TSGDataType* type, index_t y) 00558 { 00559 return true; 00560 } 00561 00562 bool 00563 CSerializableHdf5File::write_sparse_begin_wrapped( 00564 const TSGDataType* type, index_t vec_index, 00565 index_t length) 00566 { 00567 type_item_t* m_prev = m_stack_type.back(); 00568 00569 if(!dspace_select(type->m_ctype, m_prev->y, m_prev->x)) 00570 return false; 00571 00572 type_item_t* m = new type_item_t(m_stack_type.back()->name); 00573 m_stack_type.push_back(m); 00574 00575 /* ************************************************************ */ 00576 00577 if (m_prev->y == 0 && m_prev->x == 0) { 00578 hbool_t bool_buf = true; 00579 if (!group_create(m->name, STR_GROUP_PREFIX)) return false; 00580 00581 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SPARSE, 00582 &bool_buf)) return false; 00583 } else { 00584 if (!group_open(m->name, STR_GROUP_PREFIX)) return false; 00585 if (!attr_exists(STR_IS_SPARSE)) return false; 00586 } 00587 00588 m->rank = 1; m->dims[0] = length; 00589 if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL); 00590 00591 if (m->dspace < 0 && (m->dspace = H5Screate_simple( 00592 m->rank, m->dims, NULL)) < 0) 00593 return false; 00594 if ((m->dtype = new_sparseentrytype(type->m_ptype)) < 0) 00595 return false; 00596 00597 string_t name; 00598 index2string(name, STRING_LEN, type->m_ctype, m_prev->y, 00599 m_prev->x); 00600 if ((m->dset = H5Dcreate2( 00601 m_stack_h5stream.back(), name, m->dtype, m->dspace, 00602 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) 00603 return false; 00604 00605 /* ************************************************************ */ 00606 00607 char* buf = new char[sizeof_sparsetype()]; 00608 00609 *(index_t*) buf = vec_index; 00610 00611 hid_t mem_type_id; 00612 if ((mem_type_id = new_sparsetype()) < 0) return false; 00613 00614 hid_t mem_space_id; 00615 if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0) 00616 return false; 00617 00618 hobj_ref_t* sparse_ref = get_ref_sparstype(buf); 00619 if (H5Rcreate(sparse_ref, m_stack_h5stream.back(), name, 00620 H5R_OBJECT, -1) < 0) return false; 00621 00622 if (H5Dwrite(m_prev->dset, mem_type_id, mem_space_id, 00623 m_prev->dspace, H5P_DEFAULT, buf) < 0) return false; 00624 00625 if (H5Sclose(mem_space_id) < 0) return false; 00626 if (H5Tclose(mem_type_id) < 0) return false; 00627 00628 delete buf; 00629 00630 return true; 00631 } 00632 00633 bool 00634 CSerializableHdf5File::write_sparse_end_wrapped( 00635 const TSGDataType* type, index_t vec_index, 00636 index_t length) 00637 { 00638 if (!group_close()) return false; 00639 delete m_stack_type.back(); m_stack_type.pop_back(); 00640 00641 return true; 00642 } 00643 00644 bool 00645 CSerializableHdf5File::write_sparseentry_begin_wrapped( 00646 const TSGDataType* type, const TSparseEntry<char>* first_entry, 00647 index_t feat_index, index_t y) 00648 { 00649 type_item_t* m = m_stack_type.back(); 00650 00651 m->sparse_ptr = (TSparseEntry<char>*) first_entry; 00652 m->sub_y = y; 00653 00654 return true; 00655 } 00656 00657 bool 00658 CSerializableHdf5File::write_sparseentry_end_wrapped( 00659 const TSGDataType* type, const TSparseEntry<char>* first_entry, 00660 index_t feat_index, index_t y) 00661 { 00662 return true; 00663 } 00664 00665 bool 00666 CSerializableHdf5File::write_item_begin_wrapped( 00667 const TSGDataType* type, index_t y, index_t x) 00668 { 00669 type_item_t* m = m_stack_type.back(); 00670 m->y = y; m->x = x; 00671 00672 if (type->m_ptype != PT_SGOBJECT) return true; 00673 00674 string_t name; 00675 if (!index2string(name, STRING_LEN, type->m_ctype, y, x)) 00676 return false; 00677 if (!group_create(name, "")) return false; 00678 00679 return true; 00680 } 00681 00682 bool 00683 CSerializableHdf5File::write_item_end_wrapped( 00684 const TSGDataType* type, index_t y, index_t x) 00685 { 00686 if (type->m_ptype == PT_SGOBJECT) 00687 if (!group_close()) return false; 00688 00689 return true; 00690 } 00691 00692 bool 00693 CSerializableHdf5File::write_sgserializable_begin_wrapped( 00694 const TSGDataType* type, const char* sgserializable_name, 00695 EPrimitiveType generic) 00696 { 00697 hbool_t bool_buf = true; 00698 00699 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SGSERIALIZABLE, 00700 &bool_buf)) return false; 00701 00702 if (*sgserializable_name == '\0') { 00703 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_NULL, 00704 &bool_buf)) 00705 return false; 00706 return true; 00707 } 00708 00709 if (!attr_write_string(STR_INSTANCE_NAME, sgserializable_name)) 00710 return false; 00711 00712 if (generic != PT_NOT_GENERIC) { 00713 string_t buf; 00714 TSGDataType::ptype_to_string(buf, generic, STRING_LEN); 00715 if (!attr_write_string(STR_GENERIC_NAME, buf)) return false; 00716 } 00717 00718 return true; 00719 } 00720 00721 bool 00722 CSerializableHdf5File::write_sgserializable_end_wrapped( 00723 const TSGDataType* type, const char* sgserializable_name, 00724 EPrimitiveType generic) 00725 { 00726 return true; 00727 } 00728 00729 bool 00730 CSerializableHdf5File::write_type_begin_wrapped( 00731 const TSGDataType* type, const char* name, const char* prefix) 00732 { 00733 type_item_t* m = new type_item_t(name); m_stack_type.push_back(m); 00734 00735 if (type->m_ptype == PT_SGOBJECT) { 00736 if (!group_create(name, "")) return false; 00737 return true; 00738 } 00739 00740 switch (type->m_ctype) { 00741 case CT_SCALAR: 00742 m->rank = 0; 00743 if (type->m_stype == ST_STRING) m->vltype = new hvl_t[1]; 00744 break; 00745 case CT_VECTOR: 00746 m->rank = 1; m->dims[0] = *type->m_length_y; 00747 if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL); 00748 if (type->m_stype == ST_STRING) 00749 m->vltype = new hvl_t[m->dims[0]]; 00750 break; 00751 case CT_MATRIX: 00752 m->rank = 2; 00753 m->dims[0] = *type->m_length_x; m->dims[1] = *type->m_length_y; 00754 if (m->dims[0] *m->dims[1] == 0) 00755 m->dspace = H5Screate(H5S_NULL); 00756 if (type->m_stype == ST_STRING) 00757 m->vltype = new hvl_t[m->dims[0] *m->dims[1]]; 00758 break; 00759 } 00760 00761 if (m->dspace < 0 && (m->dspace = H5Screate_simple( 00762 m->rank, m->dims, NULL)) < 0) 00763 return false; 00764 if ((m->dtype = new_stype2hdf5(type->m_stype, type->m_ptype)) < 0) 00765 return false; 00766 00767 if ((m->dset = H5Dcreate2( 00768 m_stack_h5stream.back(), name, m->dtype, m->dspace, 00769 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) 00770 return false; 00771 00772 return true; 00773 } 00774 00775 bool 00776 CSerializableHdf5File::write_type_end_wrapped( 00777 const TSGDataType* type, const char* name, const char* prefix) 00778 { 00779 if (type->m_ptype == PT_SGOBJECT) 00780 if (!group_close()) return false; 00781 00782 delete m_stack_type.back(); m_stack_type.pop_back(); 00783 return true; 00784 } 00785 00786 #endif /* HAVE_HDF5 */