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