SHOGUN  v3.2.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SerializableJsonReader00.cpp
Go to the documentation of this file.
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  */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation