SHOGUN  v2.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups 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* length)
168 {
169  json_object* m = m_file->m_stack_stream.back();
170 
171  if (!json_object_is_type(m, json_type_object)) return false;
172 
173  json_object* buf;
174  if (!m_file->get_object(&buf, m, STR_KEY_SPARSE_FEATURES,
175  json_type_array)) return false;
176  *length = json_object_array_length(buf);
177  m_file->push_object(buf);
178 
179  return true;
180 }
181 
182 bool
183 SerializableJsonReader00::read_sparse_end_wrapped(
184  const TSGDataType* type, index_t length)
185 {
186  m_file->pop_object();
187  return true;
188 }
189 
190 bool
191 SerializableJsonReader00::read_sparseentry_begin_wrapped(
192  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
193  index_t* feat_index, index_t y)
194 {
195  json_object* m = m_file->m_stack_stream.back();
196 
197  json_object* buf_obj
198  = json_object_array_get_idx(m, y);
199  if (is_error(buf_obj)) return false;
200  if (!json_object_is_type(buf_obj, json_type_object)) return false;
201 
202  json_object* buf;
203  if (!m_file->get_object(&buf, buf_obj, STR_KEY_SPARSE_FEATINDEX,
204  json_type_int)) return false;
205  *feat_index = json_object_get_int(buf);
206 
207  if (!m_file->get_object_any(&buf, buf_obj, STR_KEY_SPARSE_ENTRY))
208  return false;
209  m_file->push_object(buf);
210 
211  return true;
212 }
213 
214 bool
215 SerializableJsonReader00::read_sparseentry_end_wrapped(
216  const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
217  index_t* feat_index, index_t y)
218 {
219  m_file->pop_object();
220  return true;
221 }
222 
223 bool
224 SerializableJsonReader00::read_item_begin_wrapped(
225  const TSGDataType* type, index_t y, index_t x)
226 {
227  json_object* m = m_file->m_stack_stream.back();
228 
229  if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX)
230  m = json_object_array_get_idx(m, x);
231  m = json_object_array_get_idx(m, y);
232 
233  m_file->push_object(m);
234  return true;
235 }
236 
237 bool
238 SerializableJsonReader00::read_item_end_wrapped(
239  const TSGDataType* type, index_t y, index_t x)
240 {
241  m_file->pop_object();
242  return true;
243 }
244 
245 bool
246 SerializableJsonReader00::read_sgserializable_begin_wrapped(
247  const TSGDataType* type, char* sgserializable_name,
248  EPrimitiveType* generic)
249 {
250  json_object* m = m_file->m_stack_stream.back();
251 
252  if (m == NULL || json_object_is_type(m, json_type_null)) {
253  *sgserializable_name = '\0'; return true;
254  }
255 
256  if (!json_object_is_type(m, json_type_object)) return false;
257 
258  json_object* buf;
259  if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE_NAME,
260  json_type_string)) return false;
261  strncpy(sgserializable_name, json_object_get_string(buf),
262  STRING_LEN);
263 
264  if (m_file->get_object(&buf, m, STR_KEY_GENERIC_NAME,
265  json_type_string)) {
267  generic, json_object_get_string(buf))) return false;
268  }
269 
270  if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE,
271  json_type_object)) return false;
272  m_file->push_object(buf);
273 
274  return true;
275 }
276 
277 bool
278 SerializableJsonReader00::read_sgserializable_end_wrapped(
279  const TSGDataType* type, const char* sgserializable_name,
280  EPrimitiveType generic)
281 {
282  if (*sgserializable_name == '\0') return true;
283 
284  m_file->pop_object();
285  return true;
286 }
287 
288 bool
289 SerializableJsonReader00::read_type_begin_wrapped(
290  const TSGDataType* type, const char* name, const char* prefix)
291 {
292  json_object* m = m_file->m_stack_stream.back();
293 
294  if (!json_object_is_type(m, json_type_object)) return false;
295 
296  json_object* buf_type;
297  if (!m_file->get_object(&buf_type, m, name, json_type_object))
298  return false;
299 
300  string_t str_buf; json_object* buf;
301  type->to_string(str_buf, STRING_LEN);
302  if (!m_file->get_object(&buf, buf_type, STR_KEY_TYPE,
303  json_type_string)) return false;
304  if (strcmp(str_buf, json_object_get_string(buf)) != 0)
305  return false;
306 
307  if (!m_file->get_object_any(&buf, buf_type, STR_KEY_DATA))
308  return false;
309  m_file->push_object(buf);
310 
311  return true;
312 }
313 
314 bool
315 SerializableJsonReader00::read_type_end_wrapped(
316  const TSGDataType* type, const char* name, const char* prefix)
317 {
318  m_file->pop_object();
319  return true;
320 }
321 
322 #endif /* HAVE_JSON */

SHOGUN Machine Learning Toolbox - Documentation