SHOGUN
v3.2.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 } 00024 00025 bool 00026 SerializableJsonReader00::read_scalar_wrapped( 00027 const TSGDataType* type, void* param) 00028 { 00029 json_object* m = m_file->m_stack_stream.back(); 00030 00031 switch (type->m_ptype) { 00032 case PT_BOOL: 00033 if (!json_object_is_type(m, json_type_boolean)) return false; 00034 *(bool*) param = json_object_get_boolean(m); 00035 break; 00036 case PT_CHAR: 00037 if (!json_object_is_type(m, json_type_int)) return false; 00038 *(char*) param = json_object_get_int(m); 00039 break; 00040 case PT_INT8: 00041 if (!json_object_is_type(m, json_type_int)) return false; 00042 *(int8_t*) param = json_object_get_int(m); 00043 break; 00044 case PT_UINT8: 00045 if (!json_object_is_type(m, json_type_int)) return false; 00046 *(uint8_t*) param = json_object_get_int(m); 00047 break; 00048 case PT_INT16: 00049 if (!json_object_is_type(m, json_type_int)) return false; 00050 *(int16_t*) param = json_object_get_int(m); 00051 break; 00052 case PT_UINT16: 00053 if (!json_object_is_type(m, json_type_int)) return false; 00054 *(uint16_t*) param = json_object_get_int(m); 00055 break; 00056 case PT_INT32: 00057 if (!json_object_is_type(m, json_type_int)) return false; 00058 *(int32_t*) param = json_object_get_int(m); 00059 break; 00060 case PT_UINT32: 00061 if (!json_object_is_type(m, json_type_int)) return false; 00062 *(uint32_t*) param = json_object_get_int(m); 00063 break; 00064 case PT_INT64: 00065 if (!json_object_is_type(m, json_type_int)) return false; 00066 *(int64_t*) param = json_object_get_int(m); 00067 break; 00068 case PT_UINT64: 00069 if (!json_object_is_type(m, json_type_int)) return false; 00070 *(uint64_t*) param = json_object_get_int(m); 00071 break; 00072 case PT_FLOAT32: 00073 if (!json_object_is_type(m, json_type_double)) return false; 00074 *(float32_t*) param = json_object_get_double(m); 00075 break; 00076 case PT_FLOAT64: 00077 if (!json_object_is_type(m, json_type_double)) return false; 00078 *(float64_t*) param = json_object_get_double(m); 00079 break; 00080 case PT_FLOATMAX: 00081 if (!json_object_is_type(m, json_type_double)) return false; 00082 *(floatmax_t*) param = json_object_get_double(m); 00083 break; 00084 case PT_COMPLEX128: 00085 SG_ERROR("read_scalar_wrapped(): Not supported for complex128_t" 00086 " for reading from JsonFile!"); 00087 break; 00088 case PT_SGOBJECT: 00089 case PT_UNDEFINED: 00090 SG_ERROR("read_scalar_wrapped(): Implementation error during" 00091 " reading JsonFile!"); 00092 return false; 00093 } 00094 00095 return true; 00096 } 00097 00098 bool 00099 SerializableJsonReader00::read_cont_begin_wrapped( 00100 const TSGDataType* type, index_t* len_read_y, index_t* len_read_x) 00101 { 00102 json_object* m = m_file->m_stack_stream.back(); 00103 00104 if (!json_object_is_type(m, json_type_array)) return false; 00105 00106 *len_read_y = json_object_array_length(m); 00107 00108 if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX) { 00109 *len_read_x = *len_read_y; 00110 for (index_t i=0; i<*len_read_x; i++) { 00111 json_object* buf = json_object_array_get_idx(m, i); 00112 if (!json_object_is_type(buf, json_type_array)) 00113 return false; 00114 00115 index_t len = json_object_array_length(buf); 00116 if (i == 0) *len_read_y = len; 00117 else if (*len_read_y != len) return false; 00118 } 00119 } 00120 00121 return true; 00122 } 00123 00124 bool 00125 SerializableJsonReader00::read_cont_end_wrapped( 00126 const TSGDataType* type, index_t len_read_y, index_t len_read_x) 00127 { 00128 return true; 00129 } 00130 00131 bool 00132 SerializableJsonReader00::read_string_begin_wrapped( 00133 const TSGDataType* type, index_t* length) 00134 { 00135 json_object* m = m_file->m_stack_stream.back(); 00136 00137 if (!json_object_is_type(m, json_type_array)) return false; 00138 00139 *length = json_object_array_length(m); 00140 00141 return true; 00142 } 00143 00144 bool 00145 SerializableJsonReader00::read_string_end_wrapped( 00146 const TSGDataType* type, index_t length) 00147 { 00148 return true; 00149 } 00150 00151 bool 00152 SerializableJsonReader00::read_stringentry_begin_wrapped( 00153 const TSGDataType* type, index_t y) 00154 { 00155 json_object* m = m_file->m_stack_stream.back(); 00156 00157 json_object* buf = json_object_array_get_idx(m, y); 00158 if (is_error(buf)) return false; 00159 00160 m_file->push_object(buf); 00161 return true; 00162 } 00163 00164 bool 00165 SerializableJsonReader00::read_stringentry_end_wrapped( 00166 const TSGDataType* type, index_t y) 00167 { 00168 m_file->pop_object(); 00169 return true; 00170 } 00171 00172 bool 00173 SerializableJsonReader00::read_sparse_begin_wrapped( 00174 const TSGDataType* type, index_t* length) 00175 { 00176 json_object* m = m_file->m_stack_stream.back(); 00177 00178 if (!json_object_is_type(m, json_type_object)) return false; 00179 00180 json_object* buf; 00181 if (!m_file->get_object(&buf, m, STR_KEY_SPARSE_FEATURES, 00182 json_type_array)) return false; 00183 *length = json_object_array_length(buf); 00184 m_file->push_object(buf); 00185 00186 return true; 00187 } 00188 00189 bool 00190 SerializableJsonReader00::read_sparse_end_wrapped( 00191 const TSGDataType* type, 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 // data (and so buf) can be NULL for empty objects 00315 m_file->get_object_any(&buf, buf_type, STR_KEY_DATA); 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 */