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 "lib/config.h"
00012 #ifdef HAVE_JSON
00013 
00014 #include "lib/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) {
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, TSparseEntry<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, TSparseEntry<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)
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  */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation