SHOGUN  v1.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SerializableHdf5Reader00.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 
15 
16 using namespace shogun;
17 
18 SerializableHdf5Reader00::SerializableHdf5Reader00(
19  CSerializableHdf5File* file) { m_file = file; }
20 
21 SerializableHdf5Reader00::~SerializableHdf5Reader00() {}
22 
23 bool
24 SerializableHdf5Reader00::read_scalar_wrapped(
25  const TSGDataType* type, void* param)
26 {
27  CSerializableHdf5File::type_item_t* m
28  = m_file->m_stack_type.back();
29 
30  switch (type->m_stype) {
31  case ST_NONE:
32  if (m->y != 0 || m->x != 0) return true;
33  break;
34  case ST_STRING:
35  if (m->y == -1 || m->x == -1) break;
36 
37  if (m->sub_y != 0) return true;
38 
39  memcpy(param, m->vltype[m->x*m->dims[1] + m->y].p,
40  m->vltype[m->x*m->dims[1] + m->y].len
41  *type->sizeof_ptype());
42 
43  return true;
44  case ST_SPARSE:
45  if (m->sub_y != 0) return true;
46  break;
47  }
48 
49  hid_t mem_type_id;
50  if ((mem_type_id = CSerializableHdf5File::new_stype2hdf5(
51  type->m_stype, type->m_ptype)) < 0) return false;
52 
53  switch (type->m_stype) {
54  case ST_NONE:
55  if (H5Dread(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
56  H5P_DEFAULT, param) < 0) return false;
57  break;
58  case ST_STRING:
59  if (H5Dread(m->dset, mem_type_id, H5S_ALL, H5S_ALL,
60  H5P_DEFAULT, m->vltype) < 0) return false;
61  break;
62  case ST_SPARSE:
63  if (H5Dread(m->dset, m->dtype, H5S_ALL, H5S_ALL,
64  H5P_DEFAULT, m->sparse_ptr) < 0) return false;
65  break;
66  }
67 
68  if (H5Tclose(mem_type_id) < 0) return false;
69 
70  return true;
71 }
72 
73 bool
74 SerializableHdf5Reader00::read_cont_begin_wrapped(
75  const TSGDataType* type, index_t* len_read_y, index_t* len_read_x)
76 {
77  CSerializableHdf5File::type_item_t* m
78  = m_file->m_stack_type.back();
79 
80  if (type->m_ptype != PT_SGOBJECT) {
81  switch (type->m_ctype) {
82  case CT_NDARRAY:
84  case CT_SCALAR:
85  SG_ERROR("read_cont_begin_wrapped(): Implementation error"
86  " during writing Hdf5File (0)!");
87  return false;
88  case CT_VECTOR: case CT_SGVECTOR: *len_read_y = m->dims[0]; break;
89  case CT_MATRIX: case CT_SGMATRIX:
90  *len_read_x = m->dims[0]; *len_read_y = m->dims[1];
91  break;
92  default: return false;
93  }
94 
95  return true;
96  }
97 
98  if (!m_file->attr_exists(STR_IS_CONT)) return false;
99 
100  string_t ctype_buf, buf;
101  type->to_string(ctype_buf, STRING_LEN);
102  if (!m_file->attr_read_string(STR_CTYPE_NAME, buf, STRING_LEN))
103  return false;
104  if (strcmp(ctype_buf, buf) != 0) return false;
105 
106  switch (type->m_ctype) {
107  case CT_NDARRAY:
109  case CT_SCALAR:
110  SG_ERROR("read_cont_begin_wrapped(): Implementation error"
111  " during writing Hdf5File (1)!");
112  return false;
113  case CT_MATRIX: case CT_SGMATRIX:
114  if (!m_file->attr_read_scalar(TYPE_INDEX, STR_LENGTH_X,
115  len_read_x))
116  return false;
117  /* break; */
118  case CT_VECTOR: case CT_SGVECTOR:
119  if (!m_file->attr_read_scalar(TYPE_INDEX, STR_LENGTH_Y,
120  len_read_y))
121  return false;
122  break;
123  default: return false;
124  }
125 
126  return true;
127 }
128 
129 bool
130 SerializableHdf5Reader00::read_cont_end_wrapped(
131  const TSGDataType* type, index_t len_read_y, index_t len_read_x)
132 {
133  return true;
134 }
135 
136 bool
137 SerializableHdf5Reader00::read_string_begin_wrapped(
138  const TSGDataType* type, index_t* length)
139 {
140  CSerializableHdf5File::type_item_t* m
141  = m_file->m_stack_type.back();
142 
143  if (m->y == 0 && m->x == 0) {
144  m->y = -1; m->x = -1;
145  read_scalar_wrapped(type, NULL);
146  m->y = 0; m->x = 0;
147  }
148 
149  *length = m->vltype[m->x*m->dims[1] + m->y].len;
150 
151  return true;
152 }
153 
154 bool
155 SerializableHdf5Reader00::read_string_end_wrapped(
156  const TSGDataType* type, index_t length)
157 {
158  return true;
159 }
160 
161 bool
162 SerializableHdf5Reader00::read_stringentry_begin_wrapped(
163  const TSGDataType* type, index_t y)
164 {
165  CSerializableHdf5File::type_item_t* m
166  = m_file->m_stack_type.back();
167 
168  m->sub_y = y;
169 
170  return true;
171 }
172 
173 bool
174 SerializableHdf5Reader00::read_stringentry_end_wrapped(
175  const TSGDataType* type, index_t y)
176 {
177  return true;
178 }
179 
180 bool
181 SerializableHdf5Reader00::read_sparse_begin_wrapped(
182  const TSGDataType* type, index_t* vec_index,
183  index_t* length)
184 {
185  CSerializableHdf5File::type_item_t* m_prev
186  = m_file->m_stack_type.back();
187 
188  if(!m_file->dspace_select(type->m_ctype, m_prev->y, m_prev->x))
189  return false;
190 
191  CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
192  ::type_item_t(m_prev->name);
193  m_file->m_stack_type.push_back(m);
194 
195  /* ************************************************************ */
196 
197  if (!m_file->group_open(m->name, STR_GROUP_PREFIX)) return false;
198  if (!m_file->attr_exists(STR_IS_SPARSE)) return false;
199 
200  string_t name;
201  CSerializableHdf5File::index2string(
202  name, STRING_LEN, type->m_ctype, m_prev->y, m_prev->x);
203  if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
204  H5P_DEFAULT)) < 0)
205  return false;
206 
207  if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
208  if (!CSerializableHdf5File::isequal_stype2hdf5(
209  type->m_stype, type->m_ptype, m->dtype)) return false;
210 
211  if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
212  if (H5Sget_simple_extent_ndims(m->dspace) != 1) return false;
213 
214 
215  if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
216  ) < 0) return false;
217 
218  if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
219  && m->rank != 1) return false;
220 
221  *length = m->dims[0];
222 
223  /* ************************************************************ */
224 
225  char* buf = SG_MALLOC(char, CSerializableHdf5File::sizeof_sparsetype());
226 
227  hid_t mem_type_id;
228  if ((mem_type_id = CSerializableHdf5File::new_sparsetype()) < 0)
229  return false;
230 
231  hid_t mem_space_id;
232  if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
233  return false;
234 
235  if (H5Dread(m_prev->dset, mem_type_id, mem_space_id,
236  m_prev->dspace, H5P_DEFAULT, buf) < 0) return false;
237 
238  if (H5Sclose(mem_space_id) < 0) return false;
239  if (H5Tclose(mem_type_id) < 0) return false;
240 
241  *vec_index = *(index_t*) buf;
242 
243  delete buf;
244 
245  return true;
246 }
247 
248 bool
249 SerializableHdf5Reader00::read_sparse_end_wrapped(
250  const TSGDataType* type, index_t* vec_index,
251  index_t length)
252 {
253  if (!m_file->group_close()) return false;
254 
255  delete m_file->m_stack_type.back();
256  m_file->m_stack_type.pop_back();
257 
258  return true;
259 }
260 
261 bool
262 SerializableHdf5Reader00::read_sparseentry_begin_wrapped(
263  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
264  index_t* feat_index, index_t y)
265 {
266  CSerializableHdf5File::type_item_t* m
267  = m_file->m_stack_type.back();
268 
269  m->sparse_ptr = first_entry;
270  m->sub_y = y;
271 
272  return true;
273 }
274 
275 bool
276 SerializableHdf5Reader00::read_sparseentry_end_wrapped(
277  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
278  index_t* feat_index, index_t y)
279 {
280  return true;
281 }
282 
283 bool
284 SerializableHdf5Reader00::read_item_begin_wrapped(
285  const TSGDataType* type, index_t y, index_t x)
286 {
287  CSerializableHdf5File::type_item_t* m
288  = m_file->m_stack_type.back();
289  m->y = y; m->x = x;
290 
291  if (type->m_ptype != PT_SGOBJECT) return true;
292 
293  string_t name;
294  if (!CSerializableHdf5File::index2string(
295  name, STRING_LEN, type->m_ctype, y, x)) return false;
296  if (!m_file->group_open(name, "")) return false;
297 
298  return true;
299 }
300 
301 bool
302 SerializableHdf5Reader00::read_item_end_wrapped(
303  const TSGDataType* type, index_t y, index_t x)
304 {
305  if (type->m_ptype == PT_SGOBJECT)
306  if (!m_file->group_close()) return false;
307 
308  return true;
309 }
310 
311 bool
312 SerializableHdf5Reader00::read_sgserializable_begin_wrapped(
313  const TSGDataType* type, char* sgserializable_name,
314  EPrimitiveType* generic)
315 {
316  if (!m_file->attr_exists(STR_IS_SGSERIALIZABLE)) return false;
317 
318  if (m_file->attr_exists(STR_IS_NULL)) {
319  *sgserializable_name = '\0'; return true;
320  }
321 
322  if (!m_file->attr_read_string(
323  STR_INSTANCE_NAME, sgserializable_name, STRING_LEN))
324  return false;
325 
326  if (m_file->attr_exists(STR_GENERIC_NAME)) {
327  string_t buf;
328  if (!m_file->attr_read_string(
329  STR_GENERIC_NAME, buf, STRING_LEN)) return false;
330  if (!TSGDataType::string_to_ptype(generic, buf))
331  return false;
332  }
333 
334  return true;
335 }
336 
337 bool
338 SerializableHdf5Reader00::read_sgserializable_end_wrapped(
339  const TSGDataType* type, const char* sgserializable_name,
340  EPrimitiveType generic)
341 {
342  return true;
343 }
344 
345 bool
346 SerializableHdf5Reader00::read_type_begin_wrapped(
347  const TSGDataType* type, const char* name, const char* prefix)
348 {
349  CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
350  ::type_item_t(name);
351  m_file->m_stack_type.push_back(m);
352 
353  if (type->m_ptype == PT_SGOBJECT) {
354  if (!m_file->group_open(name, "")) return false;
355  return true;
356  }
357 
358  if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
359  H5P_DEFAULT)) < 0)
360  return false;
361 
362  if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
363  if (!CSerializableHdf5File::isequal_stype2hdf5(
364  type->m_stype, type->m_ptype, m->dtype)) return false;
365 
366  if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
367 
368  if (H5Sget_simple_extent_ndims(m->dspace) > 2) return false;
369  if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
370  ) < 0) return false;
371 
372  switch (type->m_ctype) {
373  case CT_NDARRAY:
375  case CT_SCALAR:
376  if (m->rank != 0) return false;
377  if (type->m_stype == ST_STRING) m->vltype = SG_MALLOC(hvl_t, 1);
378  break;
379  case CT_VECTOR: case CT_SGVECTOR:
380  if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
381  && m->rank != 1) return false;
382  if (type->m_stype == ST_STRING)
383  m->vltype = SG_MALLOC(hvl_t, m->dims[0]);
384  break;
385  case CT_MATRIX: case CT_SGMATRIX:
386  if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
387  && m->rank != 2) return false;
388  if (type->m_stype == ST_STRING)
389  m->vltype = SG_MALLOC(hvl_t, m->dims[0] *m->dims[1]);
390  break;
391  default: return false;
392  }
393 
394  return true;
395 }
396 
397 bool
398 SerializableHdf5Reader00::read_type_end_wrapped(
399  const TSGDataType* type, const char* name, const char* prefix)
400 {
401  if (type->m_ptype == PT_SGOBJECT)
402  if (!m_file->group_close()) return false;
403 
404  delete m_file->m_stack_type.back();
405  m_file->m_stack_type.pop_back();
406  return true;
407 }
408 
409 #endif /* HAVE_HDF5 */

SHOGUN Machine Learning Toolbox - Documentation