SerializableAsciiFile.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/SerializableAsciiFile.h"
00012 #include "lib/SerializableAsciiReader00.h"
00013 
00014 #define STR_HEADER_00                 \
00015     "<<_SHOGUN_SERIALIZABLE_ASCII_FILE_V_00_>>"
00016 
00017 using namespace shogun;
00018 
00019 CSerializableAsciiFile::CSerializableAsciiFile(void)
00020     :CSerializableFile() { init(); }
00021 
00022 CSerializableAsciiFile::CSerializableAsciiFile(FILE* fstream, char rw)
00023     :CSerializableFile(fstream, rw) { init(); }
00024 
00025 CSerializableAsciiFile::CSerializableAsciiFile(
00026     const char* fname, char rw)
00027     :CSerializableFile(fname, rw) { init(); }
00028 
00029 CSerializableAsciiFile::~CSerializableAsciiFile() {}
00030 
00031 bool
00032 CSerializableAsciiFile::ignore(void)
00033 {
00034     for (uint32_t cont_count = 0, item_count = 0,
00035              sgserial_count = 0; ;) {
00036         switch (fgetc(m_fstream)) {
00037         case CHAR_ITEM_BEGIN: item_count++; break;
00038         case CHAR_CONT_BEGIN: cont_count++; break;
00039         case CHAR_SGSERIAL_BEGIN: sgserial_count++; break;
00040         case CHAR_CONT_END:
00041             if (cont_count-- == 0) return false;
00042             break;
00043         case CHAR_ITEM_END:
00044             if (item_count-- == 0) return false;
00045             break;
00046         case CHAR_SGSERIAL_END:
00047             if (sgserial_count-- == 0) return false;
00048             break;
00049         case CHAR_TYPE_END:
00050             if (cont_count == 0 && item_count == 0
00051                 && sgserial_count == 0)
00052                 return true;
00053             break;
00054         case EOF: return false;
00055         default: break;
00056         }
00057     }
00058 
00059     return false;
00060 }
00061 
00062 CSerializableFile::TSerializableReader*
00063 CSerializableAsciiFile::new_reader(char* dest_version, size_t n)
00064 {
00065     string_t buf;
00066     if (fscanf(m_fstream, "%"STRING_LEN_STR"s\n", buf) != 1)
00067         return NULL;
00068 
00069     strncpy(dest_version, buf, n < STRING_LEN? n: STRING_LEN);
00070     m_stack_fpos.push_back(ftell(m_fstream));
00071 
00072     if (strcmp(STR_HEADER_00, dest_version) == 0)
00073         return new SerializableAsciiReader00(this);
00074 
00075     return NULL;
00076 }
00077 
00078 void
00079 CSerializableAsciiFile::init(void)
00080 {
00081     if (m_fstream == NULL) return;
00082 
00083     switch (m_task) {
00084     case 'w':
00085         if (fprintf(m_fstream, STR_HEADER_00"\n") <= 0) {
00086             close(); return;
00087         }
00088         m_stack_fpos.push_back(ftell(m_fstream));
00089         break;
00090     case 'r': break;
00091     default:
00092         SG_WARNING("Could not open file `%s', unknown mode!\n",
00093                    m_filename);
00094         close(); return;
00095     }
00096 }
00097 
00098 bool
00099 CSerializableAsciiFile::write_scalar_wrapped(
00100     const TSGDataType* type, const void* param)
00101 {
00102     switch (type->m_ptype) {
00103     case PT_BOOL:
00104         if (fprintf(m_fstream, "%c", *(bool*) param? 't': 'f') <= 0)
00105             return false;
00106         break;
00107     case PT_CHAR:
00108         if (fprintf(m_fstream, "%"PRIu8, *(uint8_t*) param) <= 0)
00109             return false;
00110         break;
00111     case PT_INT8:
00112         if (fprintf(m_fstream, "%"PRIi8, *(int8_t*) param) <= 0)
00113             return false;
00114         break;
00115     case PT_UINT8:
00116         if (fprintf(m_fstream, "%"PRIu8, *(uint8_t*) param) <= 0)
00117             return false;
00118         break;
00119     case PT_INT16:
00120         if (fprintf(m_fstream, "%"PRIi16, *(int16_t*) param) <= 0)
00121             return false;
00122         break;
00123     case PT_UINT16:
00124         if (fprintf(m_fstream, "%"PRIu16, *(uint16_t*) param) <= 0)
00125             return false;
00126         break;
00127     case PT_INT32:
00128         if (fprintf(m_fstream, "%"PRIi32, *(int32_t*) param) <= 0)
00129             return false;
00130         break;
00131     case PT_UINT32:
00132         if (fprintf(m_fstream, "%"PRIu32, *(uint32_t*) param) <= 0)
00133             return false;
00134         break;
00135     case PT_INT64:
00136         if (fprintf(m_fstream, "%"PRIi64, *(int64_t*) param) <= 0)
00137             return false;
00138         break;
00139     case PT_UINT64:
00140         if (fprintf(m_fstream, "%"PRIu64, *(uint64_t*) param) <= 0)
00141             return false;
00142         break;
00143     case PT_FLOAT32:
00144         if (fprintf(m_fstream, "%.16g", *(float32_t*) param) <= 0)
00145             return false;
00146         break;
00147     case PT_FLOAT64:
00148         if (fprintf(m_fstream, "%.16lg", *(float64_t*) param) <= 0)
00149             return false;
00150         break;
00151     case PT_FLOATMAX:
00152         if (fprintf(m_fstream, "%.16Lg", *(floatmax_t*) param) <= 0)
00153             return false;
00154         break;
00155     case PT_SGOBJECT:
00156         SG_ERROR("write_scalar_wrapped(): Implementation error during"
00157                  " writing AsciiFile!");
00158         return false;
00159     }
00160 
00161     return true;
00162 }
00163 
00164 bool
00165 CSerializableAsciiFile::write_cont_begin_wrapped(
00166     const TSGDataType* type, index_t len_real_y, index_t len_real_x)
00167 {
00168     switch (type->m_ctype) {
00169     case CT_SCALAR:
00170         SG_ERROR("write_cont_begin_wrapped(): Implementation error "
00171                  "during writing AsciiFile!");
00172         return false;
00173     case CT_VECTOR:
00174         if (fprintf(m_fstream, "%"PRIi32" %c", len_real_y,
00175                     CHAR_CONT_BEGIN) <= 0)
00176             return false;
00177         break;
00178     case CT_MATRIX:
00179         if (fprintf(m_fstream, "%"PRIi32" %"PRIi32" %c",
00180                     len_real_y, len_real_x, CHAR_CONT_BEGIN) <= 0)
00181             return false;
00182         break;
00183     }
00184 
00185     return true;
00186 }
00187 
00188 bool
00189 CSerializableAsciiFile::write_cont_end_wrapped(
00190     const TSGDataType* type, index_t len_real_y, index_t len_real_x)
00191 {
00192     if (fprintf(m_fstream, "%c", CHAR_CONT_END) <= 0) return false;
00193 
00194     return true;
00195 }
00196 
00197 bool
00198 CSerializableAsciiFile::write_string_begin_wrapped(
00199     const TSGDataType* type, index_t length)
00200 {
00201     if (fprintf(m_fstream, "%"PRIi32" %c", length,
00202                 CHAR_STRING_BEGIN) <= 0) return false;
00203 
00204     return true;
00205 }
00206 
00207 bool
00208 CSerializableAsciiFile::write_string_end_wrapped(
00209     const TSGDataType* type, index_t length)
00210 {
00211     if (fprintf(m_fstream, "%c", CHAR_STRING_END) <= 0) return false;
00212 
00213     return true;
00214 }
00215 
00216 bool
00217 CSerializableAsciiFile::write_stringentry_begin_wrapped(
00218     const TSGDataType* type, index_t y)
00219 {
00220     if (fprintf(m_fstream, "%c", CHAR_ITEM_BEGIN) <= 0) return false;
00221 
00222     return true;
00223 }
00224 
00225 bool
00226 CSerializableAsciiFile::write_stringentry_end_wrapped(
00227     const TSGDataType* type, index_t y)
00228 {
00229     if (fprintf(m_fstream, "%c", CHAR_ITEM_END) <= 0) return false;
00230 
00231     return true;
00232 }
00233 
00234 bool
00235 CSerializableAsciiFile::write_sparse_begin_wrapped(
00236     const TSGDataType* type, index_t vec_index,
00237     index_t length)
00238 {
00239     if (fprintf(m_fstream, "%"PRIi32" %"PRIi32" %c", vec_index, length,
00240                 CHAR_SPARSE_BEGIN) <= 0) return false;
00241 
00242     return true;
00243 }
00244 
00245 bool
00246 CSerializableAsciiFile::write_sparse_end_wrapped(
00247     const TSGDataType* type, index_t vec_index,
00248     index_t length)
00249 {
00250     if (fprintf(m_fstream, "%c", CHAR_SPARSE_END) <= 0) return false;
00251 
00252     return true;
00253 }
00254 
00255 bool
00256 CSerializableAsciiFile::write_sparseentry_begin_wrapped(
00257     const TSGDataType* type, const TSparseEntry<char>* first_entry,
00258     index_t feat_index, index_t y)
00259 {
00260     if (fprintf(m_fstream, " %"PRIi32" %c", feat_index, CHAR_ITEM_BEGIN)
00261         <= 0) return false;
00262 
00263     return true;
00264 }
00265 
00266 bool
00267 CSerializableAsciiFile::write_sparseentry_end_wrapped(
00268     const TSGDataType* type, const TSparseEntry<char>* first_entry,
00269     index_t feat_index, index_t y)
00270 {
00271     if (fprintf(m_fstream, "%c", CHAR_ITEM_END) <= 0) return false;
00272 
00273     return true;
00274 }
00275 
00276 bool
00277 CSerializableAsciiFile::write_item_begin_wrapped(
00278     const TSGDataType* type, index_t y, index_t x)
00279 {
00280     if (fprintf(m_fstream, "%c", CHAR_ITEM_BEGIN) <= 0) return false;
00281 
00282     return true;
00283 }
00284 
00285 bool
00286 CSerializableAsciiFile::write_item_end_wrapped(
00287     const TSGDataType* type, index_t y, index_t x)
00288 {
00289     if (fprintf(m_fstream, "%c", CHAR_ITEM_END) <= 0) return false;
00290 
00291     return true;
00292 }
00293 
00294 bool
00295 CSerializableAsciiFile::write_sgserializable_begin_wrapped(
00296     const TSGDataType* type, const char* sgserializable_name,
00297     EPrimitiveType generic)
00298 {
00299     if (*sgserializable_name == '\0') {
00300         if (fprintf(m_fstream, "%s %c", STR_SGSERIAL_NULL,
00301                     CHAR_SGSERIAL_BEGIN) <= 0)
00302             return false;
00303     } else {
00304         if (fprintf(m_fstream, "%s ", sgserializable_name) <= 0)
00305             return false;
00306 
00307         if (generic != PT_NOT_GENERIC) {
00308             string_t buf;
00309             TSGDataType::ptype_to_string(buf, generic, STRING_LEN);
00310             if (fprintf(m_fstream, "%s ", buf) <= 0) return false;
00311         }
00312 
00313         if (fprintf(m_fstream, "%c%c", CHAR_SGSERIAL_BEGIN,
00314                     CHAR_TYPE_END) <= 0)
00315             return false;
00316     }
00317 
00318     return true;
00319 }
00320 
00321 bool
00322 CSerializableAsciiFile::write_sgserializable_end_wrapped(
00323     const TSGDataType* type, const char* sgserializable_name,
00324     EPrimitiveType generic)
00325 {
00326     if (fprintf(m_fstream, "%c", CHAR_SGSERIAL_END) <= 0)
00327         return false;
00328 
00329     return true;
00330 }
00331 
00332 bool
00333 CSerializableAsciiFile::write_type_begin_wrapped(
00334     const TSGDataType* type, const char* name, const char* prefix)
00335 {
00336     string_t buf;
00337     type->to_string(buf, STRING_LEN);
00338 
00339     SG_SET_LOCALE_C;
00340 
00341     if (fprintf(m_fstream, "%s %s ", name, buf) <= 0) return false;
00342 
00343     return true;
00344 }
00345 
00346 bool
00347 CSerializableAsciiFile::write_type_end_wrapped(
00348     const TSGDataType* type, const char* name, const char* prefix)
00349 {
00350     if (fprintf(m_fstream, "%c", CHAR_TYPE_END) <= 0) return false;
00351 
00352     SG_RESET_LOCALE;
00353 
00354     return true;
00355 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation