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_VINDEX, 0, TYPE_INDEX) < 0)
56 if (H5Tinsert(result, STR_SPARSE_FPTR, H5Tget_size(TYPE_INDEX),
63 CSerializableHdf5File::get_ref_sparstype(
void* sparse_buf) {
65 ((
char*) sparse_buf + H5Tget_size(TYPE_INDEX));
69 CSerializableHdf5File::new_sparseentrytype(EPrimitiveType ptype)
71 hid_t result = H5Tcreate(H5T_COMPOUND,
73 if (result < 0)
return NOT_OPEN;
75 if (H5Tinsert(result, STR_SPARSEENTRY_FINDEX,
78 if (H5Tinsert(result, STR_SPARSEENTRY_ENTRY,
TSGDataType
79 ::offset_sparseentry(ptype),
80 ptype2hdf5(ptype)) < 0)
return NOT_OPEN;
86 CSerializableHdf5File::ptype2hdf5(EPrimitiveType ptype)
90 switch (
sizeof (
bool)) {
91 case 1:
return H5T_NATIVE_UINT8;
92 case 2:
return H5T_NATIVE_UINT16;
93 case 4:
return H5T_NATIVE_UINT32;
94 case 8:
return H5T_NATIVE_UINT64;
98 case PT_CHAR:
return H5T_NATIVE_CHAR;
break;
99 case PT_INT8:
return H5T_NATIVE_INT8;
break;
100 case PT_UINT8:
return H5T_NATIVE_UINT8;
break;
101 case PT_INT16:
return H5T_NATIVE_INT16;
break;
102 case PT_UINT16:
return H5T_NATIVE_UINT16;
break;
103 case PT_INT32:
return H5T_NATIVE_INT32;
break;
104 case PT_UINT32:
return H5T_NATIVE_UINT32;
break;
105 case PT_INT64:
return H5T_NATIVE_INT64;
break;
106 case PT_UINT64:
return H5T_NATIVE_UINT64;
break;
107 case PT_FLOAT32:
return H5T_NATIVE_FLOAT;
break;
108 case PT_FLOAT64:
return H5T_NATIVE_DOUBLE;
break;
109 case PT_FLOATMAX:
return H5T_NATIVE_LDOUBLE;
break;
110 case PT_SGOBJECT:
return NOT_OPEN;
break;
117 CSerializableHdf5File::new_stype2hdf5(EStructType stype,
118 EPrimitiveType ptype)
120 hid_t result = ptype2hdf5(ptype);
123 case ST_NONE: result = H5Tcopy(result);
break;
124 case ST_STRING: result = H5Tvlen_create(result);
break;
125 case ST_SPARSE: result = new_sparsetype();
break;
133 CSerializableHdf5File::index2string(
138 case CT_SCALAR:
return false;
139 case CT_VECTOR:
case CT_SGVECTOR: snprintf(dest, n,
"y%u", y);
break;
140 case CT_MATRIX:
case CT_SGMATRIX: snprintf(dest, n,
"y%u_x%u", y, x);
break;
141 default:
return false;
148 CSerializableHdf5File::isequal_stype2hdf5(EStructType stype,
149 EPrimitiveType ptype,
152 hid_t pbuf = ptype2hdf5(ptype), pbuf2 = NOT_OPEN;
154 bool to_close =
false;
158 to_close =
true; pbuf = H5Tvlen_create(pbuf);
break;
160 to_close =
true; pbuf = new_sparsetype();
161 pbuf2 = new_sparseentrytype(ptype);
break;
164 bool result = (H5Tequal(htype, pbuf) > 0)
165 || (pbuf2 >= 0 && H5Tequal(htype, pbuf2) > 0);
167 if (pbuf2 >= 0 && H5Tclose(pbuf2) < 0)
return false;
168 if (to_close && H5Tclose(pbuf) < 0)
return false;
173 CSerializableHdf5File::dspace_select(EContainerType ctype,
index_t y,
176 type_item_t* m = m_stack_type.back();
178 if (H5Sselect_none(m->dspace) < 0)
return false;
183 case CT_SCALAR:
return false;
184 case CT_MATRIX:
case CT_SGMATRIX: coord[1] = x;
185 case CT_VECTOR:
case CT_SGVECTOR: coord[0] = y;
break;
186 default:
return false;
188 if (H5Sselect_elements(m->dspace, H5S_SELECT_SET, 1, coord) < 0)
195 CSerializableHdf5File::attr_write_scalar(
196 hid_t datatype,
const char* name,
const void* val)
199 if ((dspace = H5Screate_simple(0, NULL, NULL)) < 0)
return false;
201 if ((dtype = H5Tcopy(datatype)) < 0)
return false;
203 if ((attr = H5Acreate2(
204 m_stack_h5stream.back(), name, dtype, dspace,
205 H5P_DEFAULT, H5P_DEFAULT)) < 0)
return false;
207 if (H5Awrite(attr, datatype, val) < 0)
return false;
209 if (H5Aclose(attr) < 0)
return false;
210 if (H5Tclose(dtype) < 0)
return false;
211 if (H5Sclose(dspace) < 0)
return false;
217 CSerializableHdf5File::attr_write_string(
218 const char* name,
const char* val)
221 if ((dtype = H5Tcopy(H5T_C_S1)) < 0)
return false;
222 if (H5Tset_size(dtype, strlen(val)+1) < 0)
return false;
224 if (!attr_write_scalar(dtype, name, val))
return false;
226 if (H5Tclose(dtype) < 0)
return false;
232 CSerializableHdf5File::attr_exists(
const char* name)
234 return H5Aexists(m_stack_h5stream.back(), name) > 0;
238 CSerializableHdf5File::attr_get_size(
const char* name)
240 if (!attr_exists(name))
return 0;
243 if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
247 if ((dtype = H5Aget_type(attr)) < 0)
return 0;
249 size_t result = H5Tget_size(dtype);
251 if (H5Tclose(dtype) < 0)
return 0;
252 if (H5Aclose(attr) < 0)
return 0;
258 CSerializableHdf5File::attr_read_scalar(
259 hid_t datatype,
const char* name,
void* val)
261 if (!attr_exists(name))
return false;
264 if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
268 if ((dspace = H5Aget_space(attr)) < 0)
return false;
269 if (H5Sget_simple_extent_type(dspace) != H5S_SCALAR)
return false;
272 if ((dtype = H5Aget_type(attr)) < 0)
return false;
273 if (H5Tequal(datatype, dtype) <= 0)
return false;
275 if (H5Aread(attr, datatype, val) < 0)
return false;
277 if (H5Tclose(dtype) < 0)
return false;
278 if (H5Sclose(dspace) < 0)
return false;
279 if (H5Aclose(attr) < 0)
return false;
285 CSerializableHdf5File::attr_read_string(
286 const char* name,
char* val,
size_t n)
288 size_t size = attr_get_size(name);
289 if (size == 0 || size > n)
return false;
292 if ((dtype = H5Tcopy(H5T_C_S1)) < 0)
return false;
293 if (H5Tset_size(dtype, size) < 0)
return false;
295 if (!attr_read_scalar(dtype, name, val))
return false;
297 if (H5Tclose(dtype) < 0)
return false;
303 CSerializableHdf5File::group_create(
const char* name,
309 snprintf(gname,
STRING_LEN,
"%s%s", prefix, name);
311 m_stack_h5stream.push_back(
312 ngroup = H5Gcreate2(m_stack_h5stream.back(), gname, H5P_DEFAULT,
313 H5P_DEFAULT, H5P_DEFAULT));
314 if (ngroup < 0)
return false;
320 CSerializableHdf5File::group_open(
const char* name,
326 snprintf(gname,
STRING_LEN,
"%s%s", prefix, name);
328 m_stack_h5stream.push_back(
329 group = H5Gopen2(m_stack_h5stream.back(), gname, H5P_DEFAULT));
330 if (group < 0)
return false;
336 CSerializableHdf5File::group_close()
338 if (H5Gclose(m_stack_h5stream.back()) < 0)
return false;
339 m_stack_h5stream.pop_back();
344 CSerializableHdf5File::CSerializableHdf5File()
347 CSerializableHdf5File::CSerializableHdf5File(
const char* fname,
char rw)
350 CSerializableFile::init(NULL, rw, fname);
354 CSerializableHdf5File::~CSerializableHdf5File()
356 while (m_stack_type.get_num_elements() > 0) {
357 delete m_stack_type.back(); m_stack_type.pop_back();
364 CSerializableHdf5File::new_reader(
char* dest_version,
size_t n)
366 if (!attr_read_string(STR_KEY_FILETYPE, dest_version, n))
369 if (strcmp(STR_FILETYPE_00, dest_version) == 0)
370 return new SerializableHdf5Reader00(
this);
376 CSerializableHdf5File::init(
const char* fname)
378 if (m_filename == NULL || *m_filename ==
'\0') {
379 SG_WARNING(
"Filename not given for opening file!\n");
383 hid_t h5stream = NOT_OPEN;
386 h5stream = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT,
390 h5stream = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
393 SG_WARNING(
"Could not open file `%s', unknown mode!\n",
399 SG_WARNING(
"Could not open file `%s'!\n", m_filename);
403 m_stack_h5stream.push_back(h5stream);
406 if (!attr_write_string(STR_KEY_FILETYPE, STR_FILETYPE_00)) {
407 SG_WARNING(
"%s: Could not open file for writing during "
408 "writing filetype!\n", fname);
418 CSerializableHdf5File::close()
420 while (m_stack_h5stream.get_num_elements() > 1) {
421 if (m_stack_h5stream.back() >= 0)
422 H5Gclose(m_stack_h5stream.back());
423 m_stack_h5stream.pop_back();
426 if (m_stack_h5stream.get_num_elements() == 1) {
427 if (m_stack_h5stream.back() >= 0)
428 H5Fclose(m_stack_h5stream.back());
429 m_stack_h5stream.pop_back();
434 CSerializableHdf5File::is_opened()
436 return m_stack_h5stream.get_num_elements() > 0;
440 CSerializableHdf5File::write_scalar_wrapped(
443 type_item_t* m = m_stack_type.back();
447 if (m->y != 0 || m->x != 0)
return true;
451 m->vltype[m->x*m->dims[1] + m->y].p = (
void*) param;
454 < (
index_t) m->vltype[m->x*m->dims[1] + m->y].len-1)
455 || ((type->
m_ctype == CT_VECTOR || type->
m_ctype == CT_SGVECTOR) && m->y
458 && (m->x < (
index_t) m->dims[0]-1
459 || m->y < (
index_t) m->dims[1]-1)))
463 if (m->sub_y != 0)
return true;
465 default:
return false;
474 if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
475 H5P_DEFAULT, param) < 0)
return false;
478 if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
479 H5P_DEFAULT, m->vltype) < 0)
return false;
482 if (H5Dwrite(m->dset, m->dtype, H5S_ALL, H5S_ALL,
483 H5P_DEFAULT, m->sparse_ptr) < 0)
return false;
485 default:
return false;
488 if (H5Tclose(mem_type_id) < 0)
return false;
494 CSerializableHdf5File::write_cont_begin_wrapped(
497 hbool_t bool_buf =
true;
499 if (type->
m_ptype != PT_SGOBJECT)
return true;
501 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_CONT, &bool_buf))
506 if (!attr_write_string(STR_CTYPE_NAME, ctype_buf))
return false;
512 SG_ERROR(
"write_cont_begin_wrapped(): Implementation error "
513 "during writing Hdf5File!");
515 case CT_MATRIX:
case CT_SGMATRIX:
516 if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_X, &len_real_x))
519 case CT_VECTOR:
case CT_SGVECTOR:
520 if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_Y, &len_real_y))
523 default:
return false;
530 CSerializableHdf5File::write_cont_end_wrapped(
537 CSerializableHdf5File::write_string_begin_wrapped(
540 type_item_t* m = m_stack_type.back();
542 m->vltype[m->x*m->dims[1] + m->y].len = length;
548 CSerializableHdf5File::write_string_end_wrapped(
555 CSerializableHdf5File::write_stringentry_begin_wrapped(
558 type_item_t* m = m_stack_type.back();
566 CSerializableHdf5File::write_stringentry_end_wrapped(
573 CSerializableHdf5File::write_sparse_begin_wrapped(
577 type_item_t* m_prev = m_stack_type.back();
579 if(!dspace_select(type->
m_ctype, m_prev->y, m_prev->x))
582 type_item_t* m =
new type_item_t(m_stack_type.back()->name);
583 m_stack_type.push_back(m);
587 if (m_prev->y == 0 && m_prev->x == 0) {
588 hbool_t bool_buf =
true;
589 if (!group_create(m->name, STR_GROUP_PREFIX))
return false;
591 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SPARSE,
592 &bool_buf))
return false;
594 if (!group_open(m->name, STR_GROUP_PREFIX))
return false;
595 if (!attr_exists(STR_IS_SPARSE))
return false;
598 m->rank = 1; m->dims[0] = length;
599 if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL);
601 if (m->dspace < 0 && (m->dspace = H5Screate_simple(
602 m->rank, m->dims, NULL)) < 0)
604 if ((m->dtype = new_sparseentrytype(type->
m_ptype)) < 0)
610 if ((m->dset = H5Dcreate2(
611 m_stack_h5stream.back(), name, m->dtype, m->dspace,
612 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
617 char* buf =
SG_MALLOC(
char, sizeof_sparsetype());
622 if ((mem_type_id = new_sparsetype()) < 0)
return false;
625 if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
628 hobj_ref_t* sparse_ref = get_ref_sparstype(buf);
629 if (H5Rcreate(sparse_ref, m_stack_h5stream.back(), name,
630 H5R_OBJECT, -1) < 0)
return false;
632 if (H5Dwrite(m_prev->dset, mem_type_id, mem_space_id,
633 m_prev->dspace, H5P_DEFAULT, buf) < 0)
return false;
635 if (H5Sclose(mem_space_id) < 0)
return false;
636 if (H5Tclose(mem_type_id) < 0)
return false;
644 CSerializableHdf5File::write_sparse_end_wrapped(
648 if (!group_close())
return false;
649 delete m_stack_type.back(); m_stack_type.pop_back();
655 CSerializableHdf5File::write_sparseentry_begin_wrapped(
659 type_item_t* m = m_stack_type.back();
668 CSerializableHdf5File::write_sparseentry_end_wrapped(
676 CSerializableHdf5File::write_item_begin_wrapped(
679 type_item_t* m = m_stack_type.back();
682 if (type->
m_ptype != PT_SGOBJECT)
return true;
687 if (!group_create(name,
""))
return false;
693 CSerializableHdf5File::write_item_end_wrapped(
696 if (type->
m_ptype == PT_SGOBJECT)
697 if (!group_close())
return false;
703 CSerializableHdf5File::write_sgserializable_begin_wrapped(
704 const TSGDataType* type,
const char* sgserializable_name,
705 EPrimitiveType
generic)
707 hbool_t bool_buf =
true;
709 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SGSERIALIZABLE,
710 &bool_buf))
return false;
712 if (*sgserializable_name ==
'\0') {
713 if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_NULL,
719 if (!attr_write_string(STR_INSTANCE_NAME, sgserializable_name))
725 if (!attr_write_string(STR_GENERIC_NAME, buf))
return false;
732 CSerializableHdf5File::write_sgserializable_end_wrapped(
733 const TSGDataType* type,
const char* sgserializable_name,
734 EPrimitiveType
generic)
740 CSerializableHdf5File::write_type_begin_wrapped(
741 const TSGDataType* type,
const char* name,
const char* prefix)
743 type_item_t* m =
new type_item_t(name); m_stack_type.push_back(m);
745 if (type->
m_ptype == PT_SGOBJECT) {
746 if (!group_create(name,
""))
return false;
757 case CT_VECTOR:
case CT_SGVECTOR:
759 if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL);
760 if (type->
m_stype == ST_STRING)
761 m->vltype =
SG_MALLOC(hvl_t, m->dims[0]);
763 case CT_MATRIX:
case CT_SGMATRIX:
766 if (m->dims[0] *m->dims[1] == 0)
767 m->dspace = H5Screate(H5S_NULL);
768 if (type->
m_stype == ST_STRING)
769 m->vltype =
SG_MALLOC(hvl_t, m->dims[0] *m->dims[1]);
771 default:
return false;
774 if (m->dspace < 0 && (m->dspace = H5Screate_simple(
775 m->rank, m->dims, NULL)) < 0)
777 if ((m->dtype = new_stype2hdf5(type->
m_stype, type->
m_ptype)) < 0)
780 if ((m->dset = H5Dcreate2(
781 m_stack_h5stream.back(), name, m->dtype, m->dspace,
782 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
789 CSerializableHdf5File::write_type_end_wrapped(
790 const TSGDataType* type,
const char* name,
const char* prefix)
792 if (type->
m_ptype == PT_SGOBJECT)
793 if (!group_close())
return false;
795 delete m_stack_type.back(); m_stack_type.pop_back();