17 #define NOT_OPEN ((hid_t) -1)
19 #define STR_KEY_FILETYPE "filetype"
20 #define STR_FILETYPE_00 \
21 "_SHOGUN_SERIALIZABLE_HDF5_FILE_V_00_"
23 using namespace shogun;
25 CSerializableHdf5File::type_item_t::type_item_t(
const char* name_)
28 dims[0] = dims[1] = 0;
29 dspace = dtype = dset = NOT_OPEN;
36 CSerializableHdf5File::type_item_t::~type_item_t()
38 if (dset >= 0) H5Dclose(dset);
39 if (dtype >= 0) H5Tclose(dtype);
40 if (dspace >= 0) H5Sclose(dspace);
41 if (vltype != NULL) SG_FREE(vltype);
46 CSerializableHdf5File::sizeof_sparsetype() {
47 return H5Tget_size(TYPE_INDEX) + H5Tget_size(H5T_STD_REF_OBJ);
50 CSerializableHdf5File::new_sparsetype()
52 hid_t result = H5Tcreate(H5T_COMPOUND, sizeof_sparsetype());
54 if (H5Tinsert(result, STR_SPARSE_FPTR, H5Tget_size(TYPE_INDEX),
61 CSerializableHdf5File::get_ref_sparstype(
void* sparse_buf) {
63 ((
char*) sparse_buf + H5Tget_size(TYPE_INDEX));
67 CSerializableHdf5File::new_sparseentrytype(EPrimitiveType ptype)
69 hid_t result = H5Tcreate(H5T_COMPOUND,
71 if (result < 0)
return NOT_OPEN;
73 if (H5Tinsert(result, STR_SPARSEENTRY_FINDEX,
76 if (H5Tinsert(result, STR_SPARSEENTRY_ENTRY,
TSGDataType
77 ::offset_sparseentry(ptype),
78 ptype2hdf5(ptype)) < 0)
return NOT_OPEN;
84 CSerializableHdf5File::ptype2hdf5(EPrimitiveType ptype)
88 switch (
sizeof (
bool)) {
89 case 1:
return H5T_NATIVE_UINT8;
90 case 2:
return H5T_NATIVE_UINT16;
91 case 4:
return H5T_NATIVE_UINT32;
92 case 8:
return H5T_NATIVE_UINT64;
96 case PT_CHAR:
return H5T_NATIVE_CHAR;
break;
97 case PT_INT8:
return H5T_NATIVE_INT8;
break;
98 case PT_UINT8:
return H5T_NATIVE_UINT8;
break;
99 case PT_INT16:
return H5T_NATIVE_INT16;
break;
100 case PT_UINT16:
return H5T_NATIVE_UINT16;
break;
101 case PT_INT32:
return H5T_NATIVE_INT32;
break;
102 case PT_UINT32:
return H5T_NATIVE_UINT32;
break;
103 case PT_INT64:
return H5T_NATIVE_INT64;
break;
104 case PT_UINT64:
return H5T_NATIVE_UINT64;
break;
105 case PT_FLOAT32:
return H5T_NATIVE_FLOAT;
break;
106 case PT_FLOAT64:
return H5T_NATIVE_DOUBLE;
break;
107 case PT_FLOATMAX:
return H5T_NATIVE_LDOUBLE;
break;
108 case PT_COMPLEX128:
return NOT_OPEN;
break;
109 case PT_SGOBJECT:
return NOT_OPEN;
break;
116 CSerializableHdf5File::new_stype2hdf5(EStructType stype,
117 EPrimitiveType ptype)
119 hid_t result = ptype2hdf5(ptype);
122 case ST_NONE: result = H5Tcopy(result);
break;
123 case ST_STRING: result = H5Tvlen_create(result);
break;
124 case ST_SPARSE: result = new_sparsetype();
break;
132 CSerializableHdf5File::index2string(
137 case CT_SCALAR:
return false;
138 case CT_VECTOR:
case CT_SGVECTOR: snprintf(dest, n,
"y%u", y);
break;
139 case CT_MATRIX:
case CT_SGMATRIX: snprintf(dest, n,
"y%u_x%u", y, x);
break;
140 default:
return false;
147 CSerializableHdf5File::isequal_stype2hdf5(EStructType stype,
148 EPrimitiveType ptype,
151 hid_t pbuf = ptype2hdf5(ptype), pbuf2 = NOT_OPEN;
153 bool to_close =
false;
157 to_close =
true; pbuf = H5Tvlen_create(pbuf);
break;
159 to_close =
true; pbuf = new_sparsetype();
160 pbuf2 = new_sparseentrytype(ptype);
break;
163 bool result = (H5Tequal(htype, pbuf) > 0)
164 || (pbuf2 >= 0 && H5Tequal(htype, pbuf2) > 0);
166 if (pbuf2 >= 0 && H5Tclose(pbuf2) < 0)
return false;
167 if (to_close && H5Tclose(pbuf) < 0)
return false;
172 CSerializableHdf5File::dspace_select(EContainerType ctype,
index_t y,
175 type_item_t* m = m_stack_type.back();
177 if (H5Sselect_none(m->dspace) < 0)
return false;
182 case CT_SCALAR:
return false;
183 case CT_MATRIX:
case CT_SGMATRIX: coord[1] = x;
184 case CT_VECTOR:
case CT_SGVECTOR: coord[0] = y;
break;
185 default:
return false;
187 if (H5Sselect_elements(m->dspace, H5S_SELECT_SET, 1, coord) < 0)
194 CSerializableHdf5File::attr_write_scalar(
195 hid_t datatype,
const char* name,
const void* val)
198 if ((dspace = H5Screate_simple(0, NULL, NULL)) < 0)
return false;
200 if ((dtype = H5Tcopy(datatype)) < 0)
return false;
202 if ((attr = H5Acreate2(
203 m_stack_h5stream.back(), name, dtype, dspace,
204 H5P_DEFAULT, H5P_DEFAULT)) < 0)
return false;
206 if (H5Awrite(attr, datatype, val) < 0)
return false;
208 if (H5Aclose(attr) < 0)
return false;
209 if (H5Tclose(dtype) < 0)
return false;
210 if (H5Sclose(dspace) < 0)
return false;
216 CSerializableHdf5File::attr_write_string(
217 const char* name,
const char* val)
220 if ((dtype = H5Tcopy(H5T_C_S1)) < 0)
return false;
221 if (H5Tset_size(dtype, strlen(val)+1) < 0)
return false;
223 if (!attr_write_scalar(dtype, name, val))
return false;
225 if (H5Tclose(dtype) < 0)
return false;
231 CSerializableHdf5File::attr_exists(
const char* name)
233 return H5Aexists(m_stack_h5stream.back(), name) > 0;
237 CSerializableHdf5File::attr_get_size(
const char* name)
239 if (!attr_exists(name))
return 0;
242 if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
246 if ((dtype = H5Aget_type(attr)) < 0)
return 0;
248 size_t result = H5Tget_size(dtype);
250 if (H5Tclose(dtype) < 0)
return 0;
251 if (H5Aclose(attr) < 0)
return 0;
257 CSerializableHdf5File::attr_read_scalar(
258 hid_t datatype,
const char* name,
void* val)
260 if (!attr_exists(name))
return false;
263 if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
267 if ((dspace = H5Aget_space(attr)) < 0)
return false;
268 if (H5Sget_simple_extent_type(dspace) != H5S_SCALAR)
return false;
271 if ((dtype = H5Aget_type(attr)) < 0)
return false;
272 if (H5Tequal(datatype, dtype) <= 0)
return false;
274 if (H5Aread(attr, datatype, val) < 0)
return false;
276 if (H5Tclose(dtype) < 0)
return false;
277 if (H5Sclose(dspace) < 0)
return false;
278 if (H5Aclose(attr) < 0)
return false;
284 CSerializableHdf5File::attr_read_string(
285 const char* name,
char* val,
size_t n)
287 size_t size = attr_get_size(name);
288 if (size == 0 || size > n)
return false;
291 if ((dtype = H5Tcopy(H5T_C_S1)) < 0)
return false;
292 if (H5Tset_size(dtype, size) < 0)
return false;
294 if (!attr_read_scalar(dtype, name, val))
return false;
296 if (H5Tclose(dtype) < 0)
return false;
302 CSerializableHdf5File::group_create(
const char* name,
308 snprintf(gname,
STRING_LEN,
"%s%s", prefix, name);
310 m_stack_h5stream.push_back(
311 ngroup = H5Gcreate2(m_stack_h5stream.back(), gname, H5P_DEFAULT,
312 H5P_DEFAULT, H5P_DEFAULT));
313 if (ngroup < 0)
return false;
319 CSerializableHdf5File::group_open(
const char* name,
325 snprintf(gname,
STRING_LEN,
"%s%s", prefix, name);
327 m_stack_h5stream.push_back(
328 group = H5Gopen2(m_stack_h5stream.back(), gname, H5P_DEFAULT));
329 if (group < 0)
return false;
335 CSerializableHdf5File::group_close()
337 if (H5Gclose(m_stack_h5stream.back()) < 0)
return false;
338 m_stack_h5stream.pop_back();
343 CSerializableHdf5File::CSerializableHdf5File()
346 CSerializableHdf5File::CSerializableHdf5File(
const char* fname,
char rw)
349 CSerializableFile::init(NULL, rw, fname);
353 CSerializableHdf5File::~CSerializableHdf5File()
355 while (m_stack_type.get_num_elements() > 0) {
356 delete m_stack_type.back(); m_stack_type.pop_back();
363 CSerializableHdf5File::new_reader(
char* dest_version,
size_t n)
365 if (!attr_read_string(STR_KEY_FILETYPE, dest_version, n))
368 if (strcmp(STR_FILETYPE_00, dest_version) == 0)
369 return new SerializableHdf5Reader00(
this);
375 CSerializableHdf5File::init(
const char* fname)
377 if (m_filename == NULL || *m_filename ==
'\0') {
378 SG_WARNING(
"Filename not given for opening file!\n")
382 hid_t h5stream = NOT_OPEN;
385 h5stream = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT,
389 h5stream = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
392 SG_WARNING(
"Could not open file `%s', unknown mode!\n",
398 SG_WARNING(
"Could not open file `%s'!\n", m_filename)
402 m_stack_h5stream.push_back(h5stream);
405 if (!attr_write_string(STR_KEY_FILETYPE, STR_FILETYPE_00)) {
406 SG_WARNING(
"%s: Could not open file for writing during "
407 "writing filetype!\n", fname);
417 CSerializableHdf5File::close()
419 while (m_stack_h5stream.get_num_elements() > 1) {
420 if (m_stack_h5stream.back() >= 0)
421 H5Gclose(m_stack_h5stream.back());
422 m_stack_h5stream.pop_back();
425 if (m_stack_h5stream.get_num_elements() == 1) {
426 if (m_stack_h5stream.back() >= 0)
427 H5Fclose(m_stack_h5stream.back());
428 m_stack_h5stream.pop_back();
433 CSerializableHdf5File::is_opened()
435 return m_stack_h5stream.get_num_elements() > 0;
439 CSerializableHdf5File::write_scalar_wrapped(
442 type_item_t* m = m_stack_type.back();
446 if (m->y != 0 || m->x != 0)
return true;
450 m->vltype[m->x*m->dims[1] + m->y].p = (
void*) param;
453 < (
index_t) m->vltype[m->x*m->dims[1] + m->y].len-1)
454 || ((type->
m_ctype == CT_VECTOR || type->
m_ctype == CT_SGVECTOR) && m->y
457 && (m->x < (
index_t) m->dims[0]-1
458 || m->y < (
index_t) m->dims[1]-1)))
462 if (m->sub_y != 0)
return true;
464 default:
return false;
473 if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
474 H5P_DEFAULT, param) < 0)
return false;
477 if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
478 H5P_DEFAULT, m->vltype) < 0)
return false;
481 if (H5Dwrite(m->dset, m->dtype, H5S_ALL, H5S_ALL,
482 H5P_DEFAULT, m->sparse_ptr) < 0)
return false;
484 default:
return false;
487 if (H5Tclose(mem_type_id) < 0)
return false;
493 CSerializableHdf5File::write_cont_begin_wrapped(
496 hbool_t bool_buf =
true;
498 if (type->
m_ptype != PT_SGOBJECT)
return true;
500 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_CONT, &bool_buf))
505 if (!attr_write_string(STR_CTYPE_NAME, ctype_buf))
return false;
511 SG_ERROR(
"write_cont_begin_wrapped(): Implementation error "
512 "during writing Hdf5File!");
514 case CT_MATRIX:
case CT_SGMATRIX:
515 if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_X, &len_real_x))
518 case CT_VECTOR:
case CT_SGVECTOR:
519 if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_Y, &len_real_y))
522 default:
return false;
529 CSerializableHdf5File::write_cont_end_wrapped(
536 CSerializableHdf5File::write_string_begin_wrapped(
539 type_item_t* m = m_stack_type.back();
541 m->vltype[m->x*m->dims[1] + m->y].len = length;
547 CSerializableHdf5File::write_string_end_wrapped(
554 CSerializableHdf5File::write_stringentry_begin_wrapped(
557 type_item_t* m = m_stack_type.back();
565 CSerializableHdf5File::write_stringentry_end_wrapped(
572 CSerializableHdf5File::write_sparse_begin_wrapped(
575 type_item_t* m_prev = m_stack_type.back();
577 if(!dspace_select(type->
m_ctype, m_prev->y, m_prev->x))
580 type_item_t* m =
new type_item_t(m_stack_type.back()->name);
581 m_stack_type.push_back(m);
585 if (m_prev->y == 0 && m_prev->x == 0) {
586 hbool_t bool_buf =
true;
587 if (!group_create(m->name, STR_GROUP_PREFIX))
return false;
589 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SPARSE,
590 &bool_buf))
return false;
592 if (!group_open(m->name, STR_GROUP_PREFIX))
return false;
593 if (!attr_exists(STR_IS_SPARSE))
return false;
596 m->rank = 1; m->dims[0] = length;
597 if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL);
599 if (m->dspace < 0 && (m->dspace = H5Screate_simple(
600 m->rank, m->dims, NULL)) < 0)
602 if ((m->dtype = new_sparseentrytype(type->
m_ptype)) < 0)
608 if ((m->dset = H5Dcreate2(
609 m_stack_h5stream.back(), name, m->dtype, m->dspace,
610 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
615 char* buf = SG_MALLOC(
char, sizeof_sparsetype());
618 if ((mem_type_id = new_sparsetype()) < 0)
return false;
621 if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
624 hobj_ref_t* sparse_ref = get_ref_sparstype(buf);
625 if (H5Rcreate(sparse_ref, m_stack_h5stream.back(), name,
626 H5R_OBJECT, -1) < 0)
return false;
628 if (H5Dwrite(m_prev->dset, mem_type_id, mem_space_id,
629 m_prev->dspace, H5P_DEFAULT, buf) < 0)
return false;
631 if (H5Sclose(mem_space_id) < 0)
return false;
632 if (H5Tclose(mem_type_id) < 0)
return false;
640 CSerializableHdf5File::write_sparse_end_wrapped(
643 if (!group_close())
return false;
644 delete m_stack_type.back(); m_stack_type.pop_back();
650 CSerializableHdf5File::write_sparseentry_begin_wrapped(
654 type_item_t* m = m_stack_type.back();
663 CSerializableHdf5File::write_sparseentry_end_wrapped(
671 CSerializableHdf5File::write_item_begin_wrapped(
674 type_item_t* m = m_stack_type.back();
677 if (type->
m_ptype != PT_SGOBJECT)
return true;
682 if (!group_create(name,
""))
return false;
688 CSerializableHdf5File::write_item_end_wrapped(
691 if (type->
m_ptype == PT_SGOBJECT)
692 if (!group_close())
return false;
698 CSerializableHdf5File::write_sgserializable_begin_wrapped(
699 const TSGDataType* type,
const char* sgserializable_name,
700 EPrimitiveType
generic)
702 hbool_t bool_buf =
true;
704 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SGSERIALIZABLE,
705 &bool_buf))
return false;
707 if (*sgserializable_name ==
'\0') {
708 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_NULL,
714 if (!attr_write_string(STR_INSTANCE_NAME, sgserializable_name))
720 if (!attr_write_string(STR_GENERIC_NAME, buf))
return false;
727 CSerializableHdf5File::write_sgserializable_end_wrapped(
728 const TSGDataType* type,
const char* sgserializable_name,
729 EPrimitiveType
generic)
735 CSerializableHdf5File::write_type_begin_wrapped(
736 const TSGDataType* type,
const char* name,
const char* prefix)
738 type_item_t* m =
new type_item_t(name); m_stack_type.push_back(m);
740 if (type->
m_ptype == PT_SGOBJECT) {
741 if (!group_create(name,
""))
return false;
750 if (type->
m_stype == ST_STRING) m->vltype = SG_MALLOC(hvl_t, 1);
752 case CT_VECTOR:
case CT_SGVECTOR:
754 if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL);
755 if (type->
m_stype == ST_STRING)
756 m->vltype = SG_MALLOC(hvl_t, m->dims[0]);
758 case CT_MATRIX:
case CT_SGMATRIX:
761 if (m->dims[0] *m->dims[1] == 0)
762 m->dspace = H5Screate(H5S_NULL);
763 if (type->
m_stype == ST_STRING)
764 m->vltype = SG_MALLOC(hvl_t, m->dims[0] *m->dims[1]);
766 default:
return false;
769 if (m->dspace < 0 && (m->dspace = H5Screate_simple(
770 m->rank, m->dims, NULL)) < 0)
772 if ((m->dtype = new_stype2hdf5(type->
m_stype, type->
m_ptype)) < 0)
775 if ((m->dset = H5Dcreate2(
776 m_stack_h5stream.back(), name, m->dtype, m->dspace,
777 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
784 CSerializableHdf5File::write_type_end_wrapped(
785 const TSGDataType* type,
const char* name,
const char* prefix)
787 if (type->
m_ptype == PT_SGOBJECT)
788 if (!group_close())
return false;
790 delete m_stack_type.back(); m_stack_type.pop_back();