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

SHOGUN Machine Learning Toolbox - Documentation