00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include <shogun/lib/config.h>
00012 #ifdef HAVE_JSON
00013
00014 #include <shogun/io/SerializableJsonReader00.h>
00015
00016 using namespace shogun;
00017
00018 SerializableJsonReader00::SerializableJsonReader00(
00019 CSerializableJsonFile* file) { m_file = file; }
00020
00021 SerializableJsonReader00::~SerializableJsonReader00() {}
00022
00023 bool
00024 SerializableJsonReader00::read_scalar_wrapped(
00025 const TSGDataType* type, void* param)
00026 {
00027 json_object* m = m_file->m_stack_stream.back();
00028
00029 switch (type->m_ptype) {
00030 case PT_BOOL:
00031 if (!json_object_is_type(m, json_type_boolean)) return false;
00032 *(bool*) param = json_object_get_boolean(m);
00033 break;
00034 case PT_CHAR:
00035 if (!json_object_is_type(m, json_type_int)) return false;
00036 *(char*) param = json_object_get_int(m);
00037 break;
00038 case PT_INT8:
00039 if (!json_object_is_type(m, json_type_int)) return false;
00040 *(int8_t*) param = json_object_get_int(m);
00041 break;
00042 case PT_UINT8:
00043 if (!json_object_is_type(m, json_type_int)) return false;
00044 *(uint8_t*) param = json_object_get_int(m);
00045 break;
00046 case PT_INT16:
00047 if (!json_object_is_type(m, json_type_int)) return false;
00048 *(int16_t*) param = json_object_get_int(m);
00049 break;
00050 case PT_UINT16:
00051 if (!json_object_is_type(m, json_type_int)) return false;
00052 *(uint16_t*) param = json_object_get_int(m);
00053 break;
00054 case PT_INT32:
00055 if (!json_object_is_type(m, json_type_int)) return false;
00056 *(int32_t*) param = json_object_get_int(m);
00057 break;
00058 case PT_UINT32:
00059 if (!json_object_is_type(m, json_type_int)) return false;
00060 *(uint32_t*) param = json_object_get_int(m);
00061 break;
00062 case PT_INT64:
00063 if (!json_object_is_type(m, json_type_int)) return false;
00064 *(int64_t*) param = json_object_get_int(m);
00065 break;
00066 case PT_UINT64:
00067 if (!json_object_is_type(m, json_type_int)) return false;
00068 *(uint64_t*) param = json_object_get_int(m);
00069 break;
00070 case PT_FLOAT32:
00071 if (!json_object_is_type(m, json_type_double)) return false;
00072 *(float32_t*) param = json_object_get_double(m);
00073 break;
00074 case PT_FLOAT64:
00075 if (!json_object_is_type(m, json_type_double)) return false;
00076 *(float64_t*) param = json_object_get_double(m);
00077 break;
00078 case PT_FLOATMAX:
00079 if (!json_object_is_type(m, json_type_double)) return false;
00080 *(floatmax_t*) param = json_object_get_double(m);
00081 break;
00082 case PT_SGOBJECT:
00083 SG_ERROR("write_scalar_wrapped(): Implementation error during"
00084 " writing JsonFile!");
00085 return false;
00086 }
00087
00088 return true;
00089 }
00090
00091 bool
00092 SerializableJsonReader00::read_cont_begin_wrapped(
00093 const TSGDataType* type, index_t* len_read_y, index_t* len_read_x)
00094 {
00095 json_object* m = m_file->m_stack_stream.back();
00096
00097 if (!json_object_is_type(m, json_type_array)) return false;
00098
00099 *len_read_y = json_object_array_length(m);
00100
00101 if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX) {
00102 *len_read_x = *len_read_y;
00103 for (index_t i=0; i<*len_read_x; i++) {
00104 json_object* buf = json_object_array_get_idx(m, i);
00105 if (!json_object_is_type(buf, json_type_array))
00106 return false;
00107
00108 index_t len = json_object_array_length(buf);
00109 if (i == 0) *len_read_y = len;
00110 else if (*len_read_y != len) return false;
00111 }
00112 }
00113
00114 return true;
00115 }
00116
00117 bool
00118 SerializableJsonReader00::read_cont_end_wrapped(
00119 const TSGDataType* type, index_t len_read_y, index_t len_read_x)
00120 {
00121 return true;
00122 }
00123
00124 bool
00125 SerializableJsonReader00::read_string_begin_wrapped(
00126 const TSGDataType* type, index_t* length)
00127 {
00128 json_object* m = m_file->m_stack_stream.back();
00129
00130 if (!json_object_is_type(m, json_type_array)) return false;
00131
00132 *length = json_object_array_length(m);
00133
00134 return true;
00135 }
00136
00137 bool
00138 SerializableJsonReader00::read_string_end_wrapped(
00139 const TSGDataType* type, index_t length)
00140 {
00141 return true;
00142 }
00143
00144 bool
00145 SerializableJsonReader00::read_stringentry_begin_wrapped(
00146 const TSGDataType* type, index_t y)
00147 {
00148 json_object* m = m_file->m_stack_stream.back();
00149
00150 json_object* buf = json_object_array_get_idx(m, y);
00151 if (is_error(buf)) return false;
00152
00153 m_file->push_object(buf);
00154 return true;
00155 }
00156
00157 bool
00158 SerializableJsonReader00::read_stringentry_end_wrapped(
00159 const TSGDataType* type, index_t y)
00160 {
00161 m_file->pop_object();
00162 return true;
00163 }
00164
00165 bool
00166 SerializableJsonReader00::read_sparse_begin_wrapped(
00167 const TSGDataType* type, index_t* length)
00168 {
00169 json_object* m = m_file->m_stack_stream.back();
00170
00171 if (!json_object_is_type(m, json_type_object)) return false;
00172
00173 json_object* buf;
00174 if (!m_file->get_object(&buf, m, STR_KEY_SPARSE_FEATURES,
00175 json_type_array)) return false;
00176 *length = json_object_array_length(buf);
00177 m_file->push_object(buf);
00178
00179 return true;
00180 }
00181
00182 bool
00183 SerializableJsonReader00::read_sparse_end_wrapped(
00184 const TSGDataType* type, index_t length)
00185 {
00186 m_file->pop_object();
00187 return true;
00188 }
00189
00190 bool
00191 SerializableJsonReader00::read_sparseentry_begin_wrapped(
00192 const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
00193 index_t* feat_index, index_t y)
00194 {
00195 json_object* m = m_file->m_stack_stream.back();
00196
00197 json_object* buf_obj
00198 = json_object_array_get_idx(m, y);
00199 if (is_error(buf_obj)) return false;
00200 if (!json_object_is_type(buf_obj, json_type_object)) return false;
00201
00202 json_object* buf;
00203 if (!m_file->get_object(&buf, buf_obj, STR_KEY_SPARSE_FEATINDEX,
00204 json_type_int)) return false;
00205 *feat_index = json_object_get_int(buf);
00206
00207 if (!m_file->get_object_any(&buf, buf_obj, STR_KEY_SPARSE_ENTRY))
00208 return false;
00209 m_file->push_object(buf);
00210
00211 return true;
00212 }
00213
00214 bool
00215 SerializableJsonReader00::read_sparseentry_end_wrapped(
00216 const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
00217 index_t* feat_index, index_t y)
00218 {
00219 m_file->pop_object();
00220 return true;
00221 }
00222
00223 bool
00224 SerializableJsonReader00::read_item_begin_wrapped(
00225 const TSGDataType* type, index_t y, index_t x)
00226 {
00227 json_object* m = m_file->m_stack_stream.back();
00228
00229 if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX)
00230 m = json_object_array_get_idx(m, x);
00231 m = json_object_array_get_idx(m, y);
00232
00233 m_file->push_object(m);
00234 return true;
00235 }
00236
00237 bool
00238 SerializableJsonReader00::read_item_end_wrapped(
00239 const TSGDataType* type, index_t y, index_t x)
00240 {
00241 m_file->pop_object();
00242 return true;
00243 }
00244
00245 bool
00246 SerializableJsonReader00::read_sgserializable_begin_wrapped(
00247 const TSGDataType* type, char* sgserializable_name,
00248 EPrimitiveType* generic)
00249 {
00250 json_object* m = m_file->m_stack_stream.back();
00251
00252 if (m == NULL || json_object_is_type(m, json_type_null)) {
00253 *sgserializable_name = '\0'; return true;
00254 }
00255
00256 if (!json_object_is_type(m, json_type_object)) return false;
00257
00258 json_object* buf;
00259 if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE_NAME,
00260 json_type_string)) return false;
00261 strncpy(sgserializable_name, json_object_get_string(buf),
00262 STRING_LEN);
00263
00264 if (m_file->get_object(&buf, m, STR_KEY_GENERIC_NAME,
00265 json_type_string)) {
00266 if (!TSGDataType::string_to_ptype(
00267 generic, json_object_get_string(buf))) return false;
00268 }
00269
00270 if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE,
00271 json_type_object)) return false;
00272 m_file->push_object(buf);
00273
00274 return true;
00275 }
00276
00277 bool
00278 SerializableJsonReader00::read_sgserializable_end_wrapped(
00279 const TSGDataType* type, const char* sgserializable_name,
00280 EPrimitiveType generic)
00281 {
00282 if (*sgserializable_name == '\0') return true;
00283
00284 m_file->pop_object();
00285 return true;
00286 }
00287
00288 bool
00289 SerializableJsonReader00::read_type_begin_wrapped(
00290 const TSGDataType* type, const char* name, const char* prefix)
00291 {
00292 json_object* m = m_file->m_stack_stream.back();
00293
00294 if (!json_object_is_type(m, json_type_object)) return false;
00295
00296 json_object* buf_type;
00297 if (!m_file->get_object(&buf_type, m, name, json_type_object))
00298 return false;
00299
00300 string_t str_buf; json_object* buf;
00301 type->to_string(str_buf, STRING_LEN);
00302 if (!m_file->get_object(&buf, buf_type, STR_KEY_TYPE,
00303 json_type_string)) return false;
00304 if (strcmp(str_buf, json_object_get_string(buf)) != 0)
00305 return false;
00306
00307 if (!m_file->get_object_any(&buf, buf_type, STR_KEY_DATA))
00308 return false;
00309 m_file->push_object(buf);
00310
00311 return true;
00312 }
00313
00314 bool
00315 SerializableJsonReader00::read_type_end_wrapped(
00316 const TSGDataType* type, const char* name, const char* prefix)
00317 {
00318 m_file->pop_object();
00319 return true;
00320 }
00321
00322 #endif