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(void) {}
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* vec_index,
00168 index_t* length)
00169 {
00170 json_object* m = m_file->m_stack_stream.back();
00171
00172 if (!json_object_is_type(m, json_type_object)) return false;
00173
00174 json_object* buf;
00175 if (!m_file->get_object(&buf, m, STR_KEY_SPARSE_VECINDEX,
00176 json_type_int))
00177 return false;
00178 *vec_index = json_object_get_int(buf);
00179
00180 if (!m_file->get_object(&buf, m, STR_KEY_SPARSE_FEATURES,
00181 json_type_array)) return false;
00182 *length = json_object_array_length(buf);
00183 m_file->push_object(buf);
00184
00185 return true;
00186 }
00187
00188 bool
00189 SerializableJsonReader00::read_sparse_end_wrapped(
00190 const TSGDataType* type, index_t* vec_index,
00191 index_t length)
00192 {
00193 m_file->pop_object();
00194 return true;
00195 }
00196
00197 bool
00198 SerializableJsonReader00::read_sparseentry_begin_wrapped(
00199 const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
00200 index_t* feat_index, index_t y)
00201 {
00202 json_object* m = m_file->m_stack_stream.back();
00203
00204 json_object* buf_obj
00205 = json_object_array_get_idx(m, y);
00206 if (is_error(buf_obj)) return false;
00207 if (!json_object_is_type(buf_obj, json_type_object)) return false;
00208
00209 json_object* buf;
00210 if (!m_file->get_object(&buf, buf_obj, STR_KEY_SPARSE_FEATINDEX,
00211 json_type_int)) return false;
00212 *feat_index = json_object_get_int(buf);
00213
00214 if (!m_file->get_object_any(&buf, buf_obj, STR_KEY_SPARSE_ENTRY))
00215 return false;
00216 m_file->push_object(buf);
00217
00218 return true;
00219 }
00220
00221 bool
00222 SerializableJsonReader00::read_sparseentry_end_wrapped(
00223 const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
00224 index_t* feat_index, index_t y)
00225 {
00226 m_file->pop_object();
00227 return true;
00228 }
00229
00230 bool
00231 SerializableJsonReader00::read_item_begin_wrapped(
00232 const TSGDataType* type, index_t y, index_t x)
00233 {
00234 json_object* m = m_file->m_stack_stream.back();
00235
00236 if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX)
00237 m = json_object_array_get_idx(m, x);
00238 m = json_object_array_get_idx(m, y);
00239
00240 m_file->push_object(m);
00241 return true;
00242 }
00243
00244 bool
00245 SerializableJsonReader00::read_item_end_wrapped(
00246 const TSGDataType* type, index_t y, index_t x)
00247 {
00248 m_file->pop_object();
00249 return true;
00250 }
00251
00252 bool
00253 SerializableJsonReader00::read_sgserializable_begin_wrapped(
00254 const TSGDataType* type, char* sgserializable_name,
00255 EPrimitiveType* generic)
00256 {
00257 json_object* m = m_file->m_stack_stream.back();
00258
00259 if (m == NULL || json_object_is_type(m, json_type_null)) {
00260 *sgserializable_name = '\0'; return true;
00261 }
00262
00263 if (!json_object_is_type(m, json_type_object)) return false;
00264
00265 json_object* buf;
00266 if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE_NAME,
00267 json_type_string)) return false;
00268 strncpy(sgserializable_name, json_object_get_string(buf),
00269 STRING_LEN);
00270
00271 if (m_file->get_object(&buf, m, STR_KEY_GENERIC_NAME,
00272 json_type_string)) {
00273 if (!TSGDataType::string_to_ptype(
00274 generic, json_object_get_string(buf))) return false;
00275 }
00276
00277 if (!m_file->get_object(&buf, m, STR_KEY_INSTANCE,
00278 json_type_object)) return false;
00279 m_file->push_object(buf);
00280
00281 return true;
00282 }
00283
00284 bool
00285 SerializableJsonReader00::read_sgserializable_end_wrapped(
00286 const TSGDataType* type, const char* sgserializable_name,
00287 EPrimitiveType generic)
00288 {
00289 if (*sgserializable_name == '\0') return true;
00290
00291 m_file->pop_object();
00292 return true;
00293 }
00294
00295 bool
00296 SerializableJsonReader00::read_type_begin_wrapped(
00297 const TSGDataType* type, const char* name, const char* prefix)
00298 {
00299 json_object* m = m_file->m_stack_stream.back();
00300
00301 if (!json_object_is_type(m, json_type_object)) return false;
00302
00303 json_object* buf_type;
00304 if (!m_file->get_object(&buf_type, m, name, json_type_object))
00305 return false;
00306
00307 string_t str_buf; json_object* buf;
00308 type->to_string(str_buf, STRING_LEN);
00309 if (!m_file->get_object(&buf, buf_type, STR_KEY_TYPE,
00310 json_type_string)) return false;
00311 if (strcmp(str_buf, json_object_get_string(buf)) != 0)
00312 return false;
00313
00314 if (!m_file->get_object_any(&buf, buf_type, STR_KEY_DATA))
00315 return false;
00316 m_file->push_object(buf);
00317
00318 return true;
00319 }
00320
00321 bool
00322 SerializableJsonReader00::read_type_end_wrapped(
00323 const TSGDataType* type, const char* name, const char* prefix)
00324 {
00325 m_file->pop_object();
00326 return true;
00327 }
00328
00329 #endif