SHOGUN  v1.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SerializableJsonReader00.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_JSON
13 
15 
16 using namespace shogun;
17 
18 SerializableJsonReader00::SerializableJsonReader00(
19  CSerializableJsonFile* file) { m_file = file; }
20 
21 SerializableJsonReader00::~SerializableJsonReader00() {}
22 
23 bool
24 SerializableJsonReader00::read_scalar_wrapped(
25  const TSGDataType* type, void* param)
26 {
27  json_object* m = m_file->m_stack_stream.back();
28 
29  switch (type->m_ptype) {
30  case PT_BOOL:
31  if (!json_object_is_type(m, json_type_boolean)) return false;
32  *(bool*) param = json_object_get_boolean(m);
33  break;
34  case PT_CHAR:
35  if (!json_object_is_type(m, json_type_int)) return false;
36  *(char*) param = json_object_get_int(m);
37  break;
38  case PT_INT8:
39  if (!json_object_is_type(m, json_type_int)) return false;
40  *(int8_t*) param = json_object_get_int(m);
41  break;
42  case PT_UINT8:
43  if (!json_object_is_type(m, json_type_int)) return false;
44  *(uint8_t*) param = json_object_get_int(m);
45  break;
46  case PT_INT16:
47  if (!json_object_is_type(m, json_type_int)) return false;
48  *(int16_t*) param = json_object_get_int(m);
49  break;
50  case PT_UINT16:
51  if (!json_object_is_type(m, json_type_int)) return false;
52  *(uint16_t*) param = json_object_get_int(m);
53  break;
54  case PT_INT32:
55  if (!json_object_is_type(m, json_type_int)) return false;
56  *(int32_t*) param = json_object_get_int(m);
57  break;
58  case PT_UINT32:
59  if (!json_object_is_type(m, json_type_int)) return false;
60  *(uint32_t*) param = json_object_get_int(m);
61  break;
62  case PT_INT64:
63  if (!json_object_is_type(m, json_type_int)) return false;
64  *(int64_t*) param = json_object_get_int(m);
65  break;
66  case PT_UINT64:
67  if (!json_object_is_type(m, json_type_int)) return false;
68  *(uint64_t*) param = json_object_get_int(m);
69  break;
70  case PT_FLOAT32:
71  if (!json_object_is_type(m, json_type_double)) return false;
72  *(float32_t*) param = json_object_get_double(m);
73  break;
74  case PT_FLOAT64:
75  if (!json_object_is_type(m, json_type_double)) return false;
76  *(float64_t*) param = json_object_get_double(m);
77  break;
78  case PT_FLOATMAX:
79  if (!json_object_is_type(m, json_type_double)) return false;
80  *(floatmax_t*) param = json_object_get_double(m);
81  break;
82  case PT_SGOBJECT:
83  SG_ERROR("write_scalar_wrapped(): Implementation error during"
84  " writing JsonFile!");
85  return false;
86  }
87 
88  return true;
89 }
90 
91 bool
92 SerializableJsonReader00::read_cont_begin_wrapped(
93  const TSGDataType* type, index_t* len_read_y, index_t* len_read_x)
94 {
95  json_object* m = m_file->m_stack_stream.back();
96 
97  if (!json_object_is_type(m, json_type_array)) return false;
98 
99  *len_read_y = json_object_array_length(m);
100 
101  if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX) {
102  *len_read_x = *len_read_y;
103  for (index_t i=0; i<*len_read_x; i++) {
104  json_object* buf = json_object_array_get_idx(m, i);
105  if (!json_object_is_type(buf, json_type_array))
106  return false;
107 
108  index_t len = json_object_array_length(buf);
109  if (i == 0) *len_read_y = len;
110  else if (*len_read_y != len) return false;
111  }
112  }
113 
114  return true;
115 }
116 
117 bool
118 SerializableJsonReader00::read_cont_end_wrapped(
119  const TSGDataType* type, index_t len_read_y, index_t len_read_x)
120 {
121  return true;
122 }
123 
124 bool
125 SerializableJsonReader00::read_string_begin_wrapped(
126  const TSGDataType* type, index_t* length)
127 {
128  json_object* m = m_file->m_stack_stream.back();
129 
130  if (!json_object_is_type(m, json_type_array)) return false;
131 
132  *length = json_object_array_length(m);
133 
134  return true;
135 }
136 
137 bool
138 SerializableJsonReader00::read_string_end_wrapped(
139  const TSGDataType* type, index_t length)
140 {
141  return true;
142 }
143 
144 bool
145 SerializableJsonReader00::read_stringentry_begin_wrapped(
146  const TSGDataType* type, index_t y)
147 {
148  json_object* m = m_file->m_stack_stream.back();
149 
150  json_object* buf = json_object_array_get_idx(m, y);
151  if (is_error(buf)) return false;
152 
153  m_file->push_object(buf);
154  return true;
155 }
156 
157 bool
158 SerializableJsonReader00::read_stringentry_end_wrapped(
159  const TSGDataType* type, index_t y)
160 {
161  m_file->pop_object();
162  return true;
163 }
164 
165 bool
166 SerializableJsonReader00::read_sparse_begin_wrapped(
167  const TSGDataType* type, index_t* vec_index,
168  index_t* length)
169 {
170  json_object* m = m_file->m_stack_stream.back();
171 
172  if (!json_object_is_type(m, json_type_object)) return false;
173 
174  json_object* buf;
175  if (!m_file->get_object(&buf, m, STR_KEY_SPARSE_VECINDEX,
176  json_type_int))
177  return false;
178  *vec_index = json_object_get_int(buf);
179 
180  if (!m_file->get_object(&buf, m, STR_KEY_SPARSE_FEATURES,
181  json_type_array)) return false;
182  *length = json_object_array_length(buf);
183  m_file->push_object(buf);
184 
185  return true;
186 }
187 
188 bool
189 SerializableJsonReader00::read_sparse_end_wrapped(
190  const TSGDataType* type, index_t* vec_index,
191  index_t length)
192 {
193  m_file->pop_object();
194  return true;
195 }
196 
197 bool
198 SerializableJsonReader00::read_sparseentry_begin_wrapped(
199  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
200  index_t* feat_index, index_t y)
201 {
202  json_object* m = m_file->m_stack_stream.back();
203 
204  json_object* buf_obj
205  = json_object_array_get_idx(m, y);
206  if (is_error(buf_obj)) return false;
207  if (!json_object_is_type(buf_obj, json_type_object)) return false;
208 
209  json_object* buf;
210  if (!m_file->get_object(&buf, buf_obj, STR_KEY_SPARSE_FEATINDEX,
211  json_type_int)) return false;
212  *feat_index = json_object_get_int(buf);
213 
214  if (!m_file->get_object_any(&buf, buf_obj, STR_KEY_SPARSE_ENTRY))
215  return false;
216  m_file->push_object(buf);
217 
218  return true;
219 }
220 
221 bool
222 SerializableJsonReader00::read_sparseentry_end_wrapped(
223  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
224  index_t* feat_index, index_t y)
225 {
226  m_file->pop_object();
227  return true;
228 }
229 
230 bool
231 SerializableJsonReader00::read_item_begin_wrapped(
232  const TSGDataType* type, index_t y, index_t x)
233 {
234  json_object* m = m_file->m_stack_stream.back();
235 
236  if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX)
237  m = json_object_array_get_idx(m, x);
238  m = json_object_array_get_idx(m, y);
239 
240  m_file->push_object(m);
241  return true;
242 }
243 
244 bool
245 SerializableJsonReader00::read_item_end_wrapped(
246  const TSGDataType* type, index_t y, index_t x)
247 {
248  m_file->pop_object();
249  return true;
250 }
251 
252 bool
253 SerializableJsonReader00::read_sgserializable_begin_wrapped(
254  const TSGDataType* type, char* sgserializable_name,
255  EPrimitiveType* generic)
256 {
257  json_object* m = m_file->m_stack_stream.back();
258 
259  if (m == NULL || json_object_is_type(m, json_type_null)) {
260  *sgserializable_name = '\0'; return true;
261  }
262 
263  if (!json_object_is_type(m, json_type_object)) return false;
264 
265  json_object* buf;
266  if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE_NAME,
267  json_type_string)) return false;
268  strncpy(sgserializable_name, json_object_get_string(buf),
269  STRING_LEN);
270 
271  if (m_file->get_object(&buf, m, STR_KEY_GENERIC_NAME,
272  json_type_string)) {
274  generic, json_object_get_string(buf))) return false;
275  }
276 
277  if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE,
278  json_type_object)) return false;
279  m_file->push_object(buf);
280 
281  return true;
282 }
283 
284 bool
285 SerializableJsonReader00::read_sgserializable_end_wrapped(
286  const TSGDataType* type, const char* sgserializable_name,
287  EPrimitiveType generic)
288 {
289  if (*sgserializable_name == '\0') return true;
290 
291  m_file->pop_object();
292  return true;
293 }
294 
295 bool
296 SerializableJsonReader00::read_type_begin_wrapped(
297  const TSGDataType* type, const char* name, const char* prefix)
298 {
299  json_object* m = m_file->m_stack_stream.back();
300 
301  if (!json_object_is_type(m, json_type_object)) return false;
302 
303  json_object* buf_type;
304  if (!m_file->get_object(&buf_type, m, name, json_type_object))
305  return false;
306 
307  string_t str_buf; json_object* buf;
308  type->to_string(str_buf, STRING_LEN);
309  if (!m_file->get_object(&buf, buf_type, STR_KEY_TYPE,
310  json_type_string)) return false;
311  if (strcmp(str_buf, json_object_get_string(buf)) != 0)
312  return false;
313 
314  if (!m_file->get_object_any(&buf, buf_type, STR_KEY_DATA))
315  return false;
316  m_file->push_object(buf);
317 
318  return true;
319 }
320 
321 bool
322 SerializableJsonReader00::read_type_end_wrapped(
323  const TSGDataType* type, const char* name, const char* prefix)
324 {
325  m_file->pop_object();
326  return true;
327 }
328 
329 #endif /* HAVE_JSON */

SHOGUN Machine Learning Toolbox - Documentation