SHOGUN  v2.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups 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 
14 #include <shogun/io/SerializableHdf5Reader00.h>
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:
83  SG_NOTIMPLEMENTED;
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:
108  SG_NOTIMPLEMENTED;
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* length)
183 {
184  CSerializableHdf5File::type_item_t* m_prev
185  = m_file->m_stack_type.back();
186 
187  if(!m_file->dspace_select(type->m_ctype, m_prev->y, m_prev->x))
188  return false;
189 
190  CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
191  ::type_item_t(m_prev->name);
192  m_file->m_stack_type.push_back(m);
193 
194  /* ************************************************************ */
195 
196  if (!m_file->group_open(m->name, STR_GROUP_PREFIX)) return false;
197  if (!m_file->attr_exists(STR_IS_SPARSE)) return false;
198 
199  string_t name;
200  CSerializableHdf5File::index2string(
201  name, STRING_LEN, type->m_ctype, m_prev->y, m_prev->x);
202  if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
203  H5P_DEFAULT)) < 0)
204  return false;
205 
206  if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
207  if (!CSerializableHdf5File::isequal_stype2hdf5(
208  type->m_stype, type->m_ptype, m->dtype)) return false;
209 
210  if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
211  if (H5Sget_simple_extent_ndims(m->dspace) != 1) return false;
212 
213 
214  if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
215  ) < 0) return false;
216 
217  if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
218  && m->rank != 1) return false;
219 
220  *length = m->dims[0];
221 
222  /* ************************************************************ */
223 
224  char* buf = SG_MALLOC(char, CSerializableHdf5File::sizeof_sparsetype());
225 
226  hid_t mem_type_id;
227  if ((mem_type_id = CSerializableHdf5File::new_sparsetype()) < 0)
228  return false;
229 
230  hid_t mem_space_id;
231  if ((mem_space_id = H5Screate_simple(0, NULL, NULL)) < 0)
232  return false;
233 
234  if (H5Dread(m_prev->dset, mem_type_id, mem_space_id,
235  m_prev->dspace, H5P_DEFAULT, buf) < 0) return false;
236 
237  if (H5Sclose(mem_space_id) < 0) return false;
238  if (H5Tclose(mem_type_id) < 0) return false;
239 
240  delete buf;
241 
242  return true;
243 }
244 
245 bool
246 SerializableHdf5Reader00::read_sparse_end_wrapped(
247  const TSGDataType* type, index_t length)
248 {
249  if (!m_file->group_close()) return false;
250 
251  delete m_file->m_stack_type.back();
252  m_file->m_stack_type.pop_back();
253 
254  return true;
255 }
256 
257 bool
258 SerializableHdf5Reader00::read_sparseentry_begin_wrapped(
259  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
260  index_t* feat_index, index_t y)
261 {
262  CSerializableHdf5File::type_item_t* m
263  = m_file->m_stack_type.back();
264 
265  m->sparse_ptr = first_entry;
266  m->sub_y = y;
267 
268  return true;
269 }
270 
271 bool
272 SerializableHdf5Reader00::read_sparseentry_end_wrapped(
273  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
274  index_t* feat_index, index_t y)
275 {
276  return true;
277 }
278 
279 bool
280 SerializableHdf5Reader00::read_item_begin_wrapped(
281  const TSGDataType* type, index_t y, index_t x)
282 {
283  CSerializableHdf5File::type_item_t* m
284  = m_file->m_stack_type.back();
285  m->y = y; m->x = x;
286 
287  if (type->m_ptype != PT_SGOBJECT) return true;
288 
289  string_t name;
290  if (!CSerializableHdf5File::index2string(
291  name, STRING_LEN, type->m_ctype, y, x)) return false;
292  if (!m_file->group_open(name, "")) return false;
293 
294  return true;
295 }
296 
297 bool
298 SerializableHdf5Reader00::read_item_end_wrapped(
299  const TSGDataType* type, index_t y, index_t x)
300 {
301  if (type->m_ptype == PT_SGOBJECT)
302  if (!m_file->group_close()) return false;
303 
304  return true;
305 }
306 
307 bool
308 SerializableHdf5Reader00::read_sgserializable_begin_wrapped(
309  const TSGDataType* type, char* sgserializable_name,
310  EPrimitiveType* generic)
311 {
312  if (!m_file->attr_exists(STR_IS_SGSERIALIZABLE)) return false;
313 
314  if (m_file->attr_exists(STR_IS_NULL)) {
315  *sgserializable_name = '\0'; return true;
316  }
317 
318  if (!m_file->attr_read_string(
319  STR_INSTANCE_NAME, sgserializable_name, STRING_LEN))
320  return false;
321 
322  if (m_file->attr_exists(STR_GENERIC_NAME)) {
323  string_t buf;
324  if (!m_file->attr_read_string(
325  STR_GENERIC_NAME, buf, STRING_LEN)) return false;
326  if (!TSGDataType::string_to_ptype(generic, buf))
327  return false;
328  }
329 
330  return true;
331 }
332 
333 bool
334 SerializableHdf5Reader00::read_sgserializable_end_wrapped(
335  const TSGDataType* type, const char* sgserializable_name,
336  EPrimitiveType generic)
337 {
338  return true;
339 }
340 
341 bool
342 SerializableHdf5Reader00::read_type_begin_wrapped(
343  const TSGDataType* type, const char* name, const char* prefix)
344 {
345  CSerializableHdf5File::type_item_t* m = new CSerializableHdf5File
346  ::type_item_t(name);
347  m_file->m_stack_type.push_back(m);
348 
349  if (type->m_ptype == PT_SGOBJECT) {
350  if (!m_file->group_open(name, "")) return false;
351  return true;
352  }
353 
354  if ((m->dset = H5Dopen2(m_file->m_stack_h5stream.back(), name,
355  H5P_DEFAULT)) < 0)
356  return false;
357 
358  if ((m->dtype = H5Dget_type(m->dset)) < 0) return false;
359  if (!CSerializableHdf5File::isequal_stype2hdf5(
360  type->m_stype, type->m_ptype, m->dtype)) return false;
361 
362  if ((m->dspace = H5Dget_space(m->dset)) < 0) return false;
363 
364  if (H5Sget_simple_extent_ndims(m->dspace) > 2) return false;
365  if ((m->rank = H5Sget_simple_extent_dims(m->dspace, m->dims, NULL)
366  ) < 0) return false;
367 
368  switch (type->m_ctype) {
369  case CT_NDARRAY:
370  SG_NOTIMPLEMENTED;
371  case CT_SCALAR:
372  if (m->rank != 0) return false;
373  if (type->m_stype == ST_STRING) m->vltype = SG_MALLOC(hvl_t, 1);
374  break;
375  case CT_VECTOR: case CT_SGVECTOR:
376  if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
377  && m->rank != 1) return false;
378  if (type->m_stype == ST_STRING)
379  m->vltype = SG_MALLOC(hvl_t, m->dims[0]);
380  break;
381  case CT_MATRIX: case CT_SGMATRIX:
382  if (H5Sget_simple_extent_type(m->dspace) != H5S_NULL
383  && m->rank != 2) return false;
384  if (type->m_stype == ST_STRING)
385  m->vltype = SG_MALLOC(hvl_t, m->dims[0] *m->dims[1]);
386  break;
387  default: return false;
388  }
389 
390  return true;
391 }
392 
393 bool
394 SerializableHdf5Reader00::read_type_end_wrapped(
395  const TSGDataType* type, const char* name, const char* prefix)
396 {
397  if (type->m_ptype == PT_SGOBJECT)
398  if (!m_file->group_close()) return false;
399 
400  delete m_file->m_stack_type.back();
401  m_file->m_stack_type.pop_back();
402  return true;
403 }
404 
405 #endif /* HAVE_HDF5 */
SHOGUN Machine Learning Toolbox - Documentation