SHOGUN
v1.1.0
|
00001 /* 00002 * This program is free software; you can redistribute it and/or modify 00003 * it under the terms of the GNU General Public License as published by 00004 * the Free Software Foundation; either version 3 of the License, or 00005 * (at your option) any later version. 00006 * 00007 * Written (W) 2010 Soeren Sonnenburg 00008 * Copyright (C) 2010 Berlin Institute of Technology 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* 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 /* HAVE_JSON */