00001
00002
00003
00004
00005
00006
00007
00008
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
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;
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
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