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

SHOGUN Machine Learning Toolbox - Documentation