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