SHOGUN  v1.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SerializableHdf5File.cpp
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 3 of the License, or
5  * (at your option) any later version.
6  *
7  * Written (W) 2010 Soeren Sonnenburg
8  * Copyright (C) 2010 Berlin Institute of Technology
9  */
10 
11 #include <shogun/lib/config.h>
12 #ifdef HAVE_HDF5
13 
16 
17 #define NOT_OPEN ((hid_t) -1)
18 
19 #define STR_KEY_FILETYPE "filetype"
20 #define STR_FILETYPE_00 \
21  "_SHOGUN_SERIALIZABLE_HDF5_FILE_V_00_"
22 
23 using namespace shogun;
24 
25 CSerializableHdf5File::type_item_t::type_item_t(const char* name_)
26 {
27  rank = 0;
28  dims[0] = dims[1] = 0;
29  dspace = dtype = dset = NOT_OPEN;
30  vltype = NULL;
31  y = x = sub_y = 0;
32  sparse_ptr = NULL;
33  name = name_;
34 }
35 
36 CSerializableHdf5File::type_item_t::~type_item_t()
37 {
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);
42  /* Do not delete SPARSE_PTR */
43 }
44 
45 hid_t
46 CSerializableHdf5File::sizeof_sparsetype() {
47  return H5Tget_size(TYPE_INDEX) + H5Tget_size(H5T_STD_REF_OBJ);
48 }
49 hid_t
50 CSerializableHdf5File::new_sparsetype()
51 {
52  hid_t result = H5Tcreate(H5T_COMPOUND, sizeof_sparsetype());
53 
54  if (H5Tinsert(result, STR_SPARSE_VINDEX, 0, TYPE_INDEX) < 0)
55  return NOT_OPEN;
56  if (H5Tinsert(result, STR_SPARSE_FPTR, H5Tget_size(TYPE_INDEX),
57  H5T_STD_REF_OBJ) < 0)
58  return NOT_OPEN;
59 
60  return result;
61 }
62 hobj_ref_t*
63 CSerializableHdf5File::get_ref_sparstype(void* sparse_buf) {
64  return (hobj_ref_t*)
65  ((char*) sparse_buf + H5Tget_size(TYPE_INDEX));
66 }
67 
68 hid_t
69 CSerializableHdf5File::new_sparseentrytype(EPrimitiveType ptype)
70 {
71  hid_t result = H5Tcreate(H5T_COMPOUND,
73  if (result < 0) return NOT_OPEN;
74 
75  if (H5Tinsert(result, STR_SPARSEENTRY_FINDEX,
76  HOFFSET(SGSparseVectorEntry<char>, feat_index), TYPE_INDEX)
77  < 0) return NOT_OPEN;
78  if (H5Tinsert(result, STR_SPARSEENTRY_ENTRY, TSGDataType
79  ::offset_sparseentry(ptype),
80  ptype2hdf5(ptype)) < 0) return NOT_OPEN;
81 
82  return result;
83 }
84 
85 hid_t
86 CSerializableHdf5File::ptype2hdf5(EPrimitiveType ptype)
87 {
88  switch (ptype) {
89  case PT_BOOL:
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;
95  default: break;
96  }
97  break;
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;
111  }
112 
113  return NOT_OPEN;
114 }
115 
116 hid_t
117 CSerializableHdf5File::new_stype2hdf5(EStructType stype,
118  EPrimitiveType ptype)
119 {
120  hid_t result = ptype2hdf5(ptype);
121 
122  switch (stype) {
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;
126  default: break;
127  }
128 
129  return result;
130 }
131 
132 bool
133 CSerializableHdf5File::index2string(
134  char* dest, size_t n, EContainerType ctype, index_t y, index_t x)
135 {
136  switch (ctype) {
137  case CT_NDARRAY: SG_SNOTIMPLEMENTED;
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;
142  }
143 
144  return true;
145 }
146 
147 bool
148 CSerializableHdf5File::isequal_stype2hdf5(EStructType stype,
149  EPrimitiveType ptype,
150  hid_t htype)
151 {
152  hid_t pbuf = ptype2hdf5(ptype), pbuf2 = NOT_OPEN;
153 
154  bool to_close = false;
155  switch (stype) {
156  case ST_NONE: break;
157  case ST_STRING:
158  to_close = true; pbuf = H5Tvlen_create(pbuf); break;
159  case ST_SPARSE:
160  to_close = true; pbuf = new_sparsetype();
161  pbuf2 = new_sparseentrytype(ptype); break;
162  }
163 
164  bool result = (H5Tequal(htype, pbuf) > 0)
165  || (pbuf2 >= 0 && H5Tequal(htype, pbuf2) > 0);
166 
167  if (pbuf2 >= 0 && H5Tclose(pbuf2) < 0) return false;
168  if (to_close && H5Tclose(pbuf) < 0) return false;
169  return result;
170 }
171 
172 bool
173 CSerializableHdf5File::dspace_select(EContainerType ctype, index_t y,
174  index_t x)
175 {
176  type_item_t* m = m_stack_type.back();
177 
178  if (H5Sselect_none(m->dspace) < 0) return false;
179 
180  hsize_t coord[2];
181  switch (ctype) {
182  case CT_NDARRAY: SG_NOTIMPLEMENTED;
183  case CT_SCALAR: return false;
184  case CT_MATRIX: case CT_SGMATRIX: coord[1] = x; /* break; */
185  case CT_VECTOR: case CT_SGVECTOR: coord[0] = y; break;
186  default: return false;
187  }
188  if (H5Sselect_elements(m->dspace, H5S_SELECT_SET, 1, coord) < 0)
189  return false;
190 
191  return true;
192 }
193 
194 bool
195 CSerializableHdf5File::attr_write_scalar(
196  hid_t datatype, const char* name, const void* val)
197 {
198  hid_t dspace;
199  if ((dspace = H5Screate_simple(0, NULL, NULL)) < 0) return false;
200  hid_t dtype;
201  if ((dtype = H5Tcopy(datatype)) < 0) return false;
202  hid_t attr;
203  if ((attr = H5Acreate2(
204  m_stack_h5stream.back(), name, dtype, dspace,
205  H5P_DEFAULT, H5P_DEFAULT)) < 0) return false;
206 
207  if (H5Awrite(attr, datatype, val) < 0) return false;
208 
209  if (H5Aclose(attr) < 0) return false;
210  if (H5Tclose(dtype) < 0) return false;
211  if (H5Sclose(dspace) < 0) return false;
212 
213  return true;
214 }
215 
216 bool
217 CSerializableHdf5File::attr_write_string(
218  const char* name, const char* val)
219 {
220  hid_t dtype;
221  if ((dtype = H5Tcopy(H5T_C_S1)) < 0) return false;
222  if (H5Tset_size(dtype, strlen(val)+1) < 0) return false;
223 
224  if (!attr_write_scalar(dtype, name, val)) return false;
225 
226  if (H5Tclose(dtype) < 0) return false;
227 
228  return true;
229 }
230 
231 bool
232 CSerializableHdf5File::attr_exists(const char* name)
233 {
234  return H5Aexists(m_stack_h5stream.back(), name) > 0;
235 }
236 
237 size_t
238 CSerializableHdf5File::attr_get_size(const char* name)
239 {
240  if (!attr_exists(name)) return 0;
241 
242  hid_t attr;
243  if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
244  < 0) return 0;
245 
246  hid_t dtype;
247  if ((dtype = H5Aget_type(attr)) < 0) return 0;
248 
249  size_t result = H5Tget_size(dtype);
250 
251  if (H5Tclose(dtype) < 0) return 0;
252  if (H5Aclose(attr) < 0) return 0;
253 
254  return result;
255 }
256 
257 bool
258 CSerializableHdf5File::attr_read_scalar(
259  hid_t datatype, const char* name, void* val)
260 {
261  if (!attr_exists(name)) return false;
262 
263  hid_t attr;
264  if ((attr = H5Aopen(m_stack_h5stream.back(), name, H5P_DEFAULT))
265  < 0) return false;
266 
267  hid_t dspace;
268  if ((dspace = H5Aget_space(attr)) < 0) return false;
269  if (H5Sget_simple_extent_type(dspace) != H5S_SCALAR) return false;
270 
271  hid_t dtype;
272  if ((dtype = H5Aget_type(attr)) < 0) return false;
273  if (H5Tequal(datatype, dtype) <= 0) return false;
274 
275  if (H5Aread(attr, datatype, val) < 0) return false;
276 
277  if (H5Tclose(dtype) < 0) return false;
278  if (H5Sclose(dspace) < 0) return false;
279  if (H5Aclose(attr) < 0) return false;
280 
281  return true;
282 }
283 
284 bool
285 CSerializableHdf5File::attr_read_string(
286  const char* name, char* val, size_t n)
287 {
288  size_t size = attr_get_size(name);
289  if (size == 0 || size > n) return false;
290 
291  hid_t dtype;
292  if ((dtype = H5Tcopy(H5T_C_S1)) < 0) return false;
293  if (H5Tset_size(dtype, size) < 0) return false;
294 
295  if (!attr_read_scalar(dtype, name, val)) return false;
296 
297  if (H5Tclose(dtype) < 0) return false;
298 
299  return true;
300 }
301 
302 bool
303 CSerializableHdf5File::group_create(const char* name,
304  const char* prefix)
305 {
306  hid_t ngroup;
307  string_t gname;
308 
309  snprintf(gname, STRING_LEN, "%s%s", prefix, name);
310 
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;
315 
316  return true;
317 }
318 
319 bool
320 CSerializableHdf5File::group_open(const char* name,
321  const char* prefix)
322 {
323  hid_t group;
324  string_t gname;
325 
326  snprintf(gname, STRING_LEN, "%s%s", prefix, name);
327 
328  m_stack_h5stream.push_back(
329  group = H5Gopen2(m_stack_h5stream.back(), gname, H5P_DEFAULT));
330  if (group < 0) return false;
331 
332  return true;
333 }
334 
335 bool
336 CSerializableHdf5File::group_close()
337 {
338  if (H5Gclose(m_stack_h5stream.back()) < 0) return false;
339  m_stack_h5stream.pop_back();
340 
341  return true;
342 }
343 
344 CSerializableHdf5File::CSerializableHdf5File()
345  :CSerializableFile() { init(""); }
346 
347 CSerializableHdf5File::CSerializableHdf5File(const char* fname, char rw)
349 {
350  CSerializableFile::init(NULL, rw, fname);
351  init(fname);
352 }
353 
354 CSerializableHdf5File::~CSerializableHdf5File()
355 {
356  while (m_stack_type.get_num_elements() > 0) {
357  delete m_stack_type.back(); m_stack_type.pop_back();
358  }
359 
360  close();
361 }
362 
364 CSerializableHdf5File::new_reader(char* dest_version, size_t n)
365 {
366  if (!attr_read_string(STR_KEY_FILETYPE, dest_version, n))
367  return NULL;
368 
369  if (strcmp(STR_FILETYPE_00, dest_version) == 0)
370  return new SerializableHdf5Reader00(this);
371 
372  return NULL;
373 }
374 
375 void
376 CSerializableHdf5File::init(const char* fname)
377 {
378  if (m_filename == NULL || *m_filename == '\0') {
379  SG_WARNING("Filename not given for opening file!\n");
380  close(); return;
381  }
382 
383  hid_t h5stream = NOT_OPEN;
384  switch (m_task) {
385  case 'w':
386  h5stream = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT,
387  H5P_DEFAULT);
388  break;
389  case 'r':
390  h5stream = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
391  break;
392  default:
393  SG_WARNING("Could not open file `%s', unknown mode!\n",
394  m_filename);
395  close(); return;
396  }
397 
398  if (h5stream < 0) {
399  SG_WARNING("Could not open file `%s'!\n", m_filename);
400  close(); return;
401  }
402 
403  m_stack_h5stream.push_back(h5stream);
404  switch (m_task) {
405  case 'w':
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);
409  close(); return;
410  }
411  break;
412  case 'r': break;
413  default: break;
414  }
415 }
416 
417 void
418 CSerializableHdf5File::close()
419 {
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();
424  }
425 
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();
430  }
431 }
432 
433 bool
434 CSerializableHdf5File::is_opened()
435 {
436  return m_stack_h5stream.get_num_elements() > 0;
437 }
438 
439 bool
440 CSerializableHdf5File::write_scalar_wrapped(
441  const TSGDataType* type, const void* param)
442 {
443  type_item_t* m = m_stack_type.back();
444 
445  switch (type->m_stype) {
446  case ST_NONE:
447  if (m->y != 0 || m->x != 0) return true;
448  break;
449  case ST_STRING:
450  if (m->sub_y == 0)
451  m->vltype[m->x*m->dims[1] + m->y].p = (void*) param;
452 
453  if ((m->sub_y
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
456  < (index_t) m->dims[0]-1)
457  || ((type->m_ctype == CT_MATRIX || type->m_ctype==CT_SGMATRIX)
458  && (m->x < (index_t) m->dims[0]-1
459  || m->y < (index_t) m->dims[1]-1)))
460  return true;
461  break;
462  case ST_SPARSE:
463  if (m->sub_y != 0) return true;
464  break;
465  default: return false;
466  }
467 
468  hid_t mem_type_id;
469  if ((mem_type_id = new_stype2hdf5(type->m_stype, type->m_ptype)
470  ) < 0) return false;
471 
472  switch (type->m_stype) {
473  case ST_NONE:
474  if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
475  H5P_DEFAULT, param) < 0) return false;
476  break;
477  case ST_STRING:
478  if (H5Dwrite(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
479  H5P_DEFAULT, m->vltype) < 0) return false;
480  break;
481  case ST_SPARSE:
482  if (H5Dwrite(m->dset, m->dtype, H5S_ALL, H5S_ALL,
483  H5P_DEFAULT, m->sparse_ptr) < 0) return false;
484  break;
485  default: return false;
486  }
487 
488  if (H5Tclose(mem_type_id) < 0) return false;
489 
490  return true;
491 }
492 
493 bool
494 CSerializableHdf5File::write_cont_begin_wrapped(
495  const TSGDataType* type, index_t len_real_y, index_t len_real_x)
496 {
497  hbool_t bool_buf = true;
498 
499  if (type->m_ptype != PT_SGOBJECT) return true;
500 
501  if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_CONT, &bool_buf))
502  return false;
503 
504  string_t ctype_buf;
505  type->to_string(ctype_buf, STRING_LEN);
506  if (!attr_write_string(STR_CTYPE_NAME, ctype_buf)) return false;
507 
508  switch (type->m_ctype) {
509  case CT_NDARRAY:
511  case CT_SCALAR:
512  SG_ERROR("write_cont_begin_wrapped(): Implementation error "
513  "during writing Hdf5File!");
514  return false;
515  case CT_MATRIX: case CT_SGMATRIX:
516  if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_X, &len_real_x))
517  return false;
518  /* break; */
519  case CT_VECTOR: case CT_SGVECTOR:
520  if (!attr_write_scalar(TYPE_INDEX, STR_LENGTH_Y, &len_real_y))
521  return false;
522  break;
523  default: return false;
524  }
525 
526  return true;
527 }
528 
529 bool
530 CSerializableHdf5File::write_cont_end_wrapped(
531  const TSGDataType* type, index_t len_real_y, index_t len_real_x)
532 {
533  return true;
534 }
535 
536 bool
537 CSerializableHdf5File::write_string_begin_wrapped(
538  const TSGDataType* type, index_t length)
539 {
540  type_item_t* m = m_stack_type.back();
541 
542  m->vltype[m->x*m->dims[1] + m->y].len = length;
543 
544  return true;
545 }
546 
547 bool
548 CSerializableHdf5File::write_string_end_wrapped(
549  const TSGDataType* type, index_t length)
550 {
551  return true;
552 }
553 
554 bool
555 CSerializableHdf5File::write_stringentry_begin_wrapped(
556  const TSGDataType* type, index_t y)
557 {
558  type_item_t* m = m_stack_type.back();
559 
560  m->sub_y = y;
561 
562  return true;
563 }
564 
565 bool
566 CSerializableHdf5File::write_stringentry_end_wrapped(
567  const TSGDataType* type, index_t y)
568 {
569  return true;
570 }
571 
572 bool
573 CSerializableHdf5File::write_sparse_begin_wrapped(
574  const TSGDataType* type, index_t vec_index,
575  index_t length)
576 {
577  type_item_t* m_prev = m_stack_type.back();
578 
579  if(!dspace_select(type->m_ctype, m_prev->y, m_prev->x))
580  return false;
581 
582  type_item_t* m = new type_item_t(m_stack_type.back()->name);
583  m_stack_type.push_back(m);
584 
585  /* ************************************************************ */
586 
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;
590 
591  if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SPARSE,
592  &bool_buf)) return false;
593  } else {
594  if (!group_open(m->name, STR_GROUP_PREFIX)) return false;
595  if (!attr_exists(STR_IS_SPARSE)) return false;
596  }
597 
598  m->rank = 1; m->dims[0] = length;
599  if (m->dims[0] == 0) m->dspace = H5Screate(H5S_NULL);
600 
601  if (m->dspace < 0 && (m->dspace = H5Screate_simple(
602  m->rank, m->dims, NULL)) < 0)
603  return false;
604  if ((m->dtype = new_sparseentrytype(type->m_ptype)) < 0)
605  return false;
606 
607  string_t name;
608  index2string(name, STRING_LEN, type->m_ctype, m_prev->y,
609  m_prev->x);
610  if ((m->dset = H5Dcreate2(
611  m_stack_h5stream.back(), name, m->dtype, m->dspace,
612  H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
613  return false;
614 
615  /* ************************************************************ */
616 
617  char* buf = SG_MALLOC(char, sizeof_sparsetype());
618 
619  *(index_t*) buf = vec_index;
620 
621  hid_t mem_type_id;
622  if ((mem_type_id = new_sparsetype()) < 0) return false;
623 
624  hid_t mem_space_id;
625  if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
626  return false;
627 
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;
631 
632  if (H5Dwrite(m_prev->dset, mem_type_id, mem_space_id,
633  m_prev->dspace, H5P_DEFAULT, buf) < 0) return false;
634 
635  if (H5Sclose(mem_space_id) < 0) return false;
636  if (H5Tclose(mem_type_id) < 0) return false;
637 
638  delete buf;
639 
640  return true;
641 }
642 
643 bool
644 CSerializableHdf5File::write_sparse_end_wrapped(
645  const TSGDataType* type, index_t vec_index,
646  index_t length)
647 {
648  if (!group_close()) return false;
649  delete m_stack_type.back(); m_stack_type.pop_back();
650 
651  return true;
652 }
653 
654 bool
655 CSerializableHdf5File::write_sparseentry_begin_wrapped(
656  const TSGDataType* type, const SGSparseVectorEntry<char>* first_entry,
657  index_t feat_index, index_t y)
658 {
659  type_item_t* m = m_stack_type.back();
660 
661  m->sparse_ptr = (SGSparseVectorEntry<char>*) first_entry;
662  m->sub_y = y;
663 
664  return true;
665 }
666 
667 bool
668 CSerializableHdf5File::write_sparseentry_end_wrapped(
669  const TSGDataType* type, const SGSparseVectorEntry<char>* first_entry,
670  index_t feat_index, index_t y)
671 {
672  return true;
673 }
674 
675 bool
676 CSerializableHdf5File::write_item_begin_wrapped(
677  const TSGDataType* type, index_t y, index_t x)
678 {
679  type_item_t* m = m_stack_type.back();
680  m->y = y; m->x = x;
681 
682  if (type->m_ptype != PT_SGOBJECT) return true;
683 
684  string_t name;
685  if (!index2string(name, STRING_LEN, type->m_ctype, y, x))
686  return false;
687  if (!group_create(name, "")) return false;
688 
689  return true;
690 }
691 
692 bool
693 CSerializableHdf5File::write_item_end_wrapped(
694  const TSGDataType* type, index_t y, index_t x)
695 {
696  if (type->m_ptype == PT_SGOBJECT)
697  if (!group_close()) return false;
698 
699  return true;
700 }
701 
702 bool
703 CSerializableHdf5File::write_sgserializable_begin_wrapped(
704  const TSGDataType* type, const char* sgserializable_name,
705  EPrimitiveType generic)
706 {
707  hbool_t bool_buf = true;
708 
709  if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_SGSERIALIZABLE,
710  &bool_buf)) return false;
711 
712  if (*sgserializable_name == '\0') {
713  if (!attr_write_scalar(H5T_NATIVE_HBOOL, STR_IS_NULL,
714  &bool_buf))
715  return false;
716  return true;
717  }
718 
719  if (!attr_write_string(STR_INSTANCE_NAME, sgserializable_name))
720  return false;
721 
722  if (generic != PT_NOT_GENERIC) {
723  string_t buf;
725  if (!attr_write_string(STR_GENERIC_NAME, buf)) return false;
726  }
727 
728  return true;
729 }
730 
731 bool
732 CSerializableHdf5File::write_sgserializable_end_wrapped(
733  const TSGDataType* type, const char* sgserializable_name,
734  EPrimitiveType generic)
735 {
736  return true;
737 }
738 
739 bool
740 CSerializableHdf5File::write_type_begin_wrapped(
741  const TSGDataType* type, const char* name, const char* prefix)
742 {
743  type_item_t* m = new type_item_t(name); m_stack_type.push_back(m);
744 
745  if (type->m_ptype == PT_SGOBJECT) {
746  if (!group_create(name, "")) return false;
747  return true;
748  }
749 
750  switch (type->m_ctype) {
751  case CT_NDARRAY:
753  case CT_SCALAR:
754  m->rank = 0;
755  if (type->m_stype == ST_STRING) m->vltype = SG_MALLOC(hvl_t, 1);
756  break;
757  case CT_VECTOR: case CT_SGVECTOR:
758  m->rank = 1; m->dims[0] = *type->m_length_y;
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]);
762  break;
763  case CT_MATRIX: case CT_SGMATRIX:
764  m->rank = 2;
765  m->dims[0] = *type->m_length_x; m->dims[1] = *type->m_length_y;
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]);
770  break;
771  default: return false;
772  }
773 
774  if (m->dspace < 0 && (m->dspace = H5Screate_simple(
775  m->rank, m->dims, NULL)) < 0)
776  return false;
777  if ((m->dtype = new_stype2hdf5(type->m_stype, type->m_ptype)) < 0)
778  return false;
779 
780  if ((m->dset = H5Dcreate2(
781  m_stack_h5stream.back(), name, m->dtype, m->dspace,
782  H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
783  return false;
784 
785  return true;
786 }
787 
788 bool
789 CSerializableHdf5File::write_type_end_wrapped(
790  const TSGDataType* type, const char* name, const char* prefix)
791 {
792  if (type->m_ptype == PT_SGOBJECT)
793  if (!group_close()) return false;
794 
795  delete m_stack_type.back(); m_stack_type.pop_back();
796  return true;
797 }
798 
799 #endif /* HAVE_HDF5 */

SHOGUN Machine Learning Toolbox - Documentation