SerializableFile.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) 1999-2010 Soeren Sonnenburg
00008  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
00009  * Copyright (C) 2010 Berlin Institute of Technology
00010  */
00011 
00012 #include <shogun/io/SerializableFile.h>
00013 
00014 using namespace shogun;
00015 
00016 CSerializableFile::CSerializableFile()
00017     :CSGObject()
00018 {
00019     init(NULL, 0, "(file)");
00020 }
00021 
00022 CSerializableFile::CSerializableFile(FILE* fstream, char rw)
00023     :CSGObject()
00024 {
00025     init(fstream, rw, "(file)");
00026 }
00027 
00028 CSerializableFile::CSerializableFile(const char* fname, char rw)
00029     :CSGObject()
00030 {
00031     char mode[3] = {rw, 'b', '\0'};
00032 
00033     init(NULL, rw, fname);
00034 
00035     if (m_filename == NULL || *m_filename == '\0') {
00036         SG_WARNING("Filename not given for opening file!\n");
00037         close(); return;
00038     }
00039 
00040     if (rw != 'r' && rw != 'w') {
00041         SG_WARNING("Unknown mode '%c'!\n", mode[0]);
00042         close(); return;
00043     }
00044 
00045     m_fstream = fopen(m_filename, mode);
00046     if (!is_opened()) {
00047         SG_WARNING("Error opening file '%s'\n", m_filename);
00048         close(); return;
00049     }
00050 }
00051 
00052 CSerializableFile::~CSerializableFile()
00053 {
00054     close();
00055     SG_FREE(m_filename);
00056     delete m_reader;
00057     m_task = 0;
00058 }
00059 
00060 void
00061 CSerializableFile::init(FILE* fstream, char task, const char* filename)
00062 {
00063     m_fstream = fstream; m_task = task; m_filename = strdup(filename);
00064     m_reader = NULL;
00065 }
00066 
00067 void
00068 CSerializableFile::close()
00069 {
00070     if (is_opened()) { fclose(m_fstream); m_fstream = NULL; }
00071 }
00072 
00073 bool
00074 CSerializableFile::is_opened()
00075 {
00076     return m_fstream != NULL;
00077 }
00078 
00079 bool
00080 CSerializableFile::is_task_warn(char rw, const char* name,
00081                                 const char* prefix)
00082 {
00083     if (m_task == 'r' && m_reader == NULL) {
00084         string_t dest_version;
00085         strncpy(dest_version, "(unkown)", STRING_LEN);
00086         m_reader = new_reader(dest_version, STRING_LEN);
00087         if (m_reader == NULL) {
00088             SG_WARNING("`%s' has file-version `%s', which is not "
00089                        "supported!\n", m_filename, dest_version);
00090             close(); return false;
00091         }
00092     }
00093 
00094     if (rw == 'w' && (m_task != 'w' || !is_opened())) {
00095         SG_WARNING("`%s' not opened (for writing) during writing "
00096                    "`%s%s'!\n", m_filename, prefix, name);
00097         return false;
00098     }
00099     if (rw == 'r' && (m_task != 'r' || !is_opened())) {
00100         SG_WARNING("`%s' not opened (for reading) during reading "
00101                    "`%s%s'!\n", m_filename, prefix, name);
00102         return false;
00103     }
00104 
00105     return true;
00106 }
00107 
00108 bool
00109 CSerializableFile::false_warn(const char* prefix, const char* name)
00110 {
00111     if (m_task == 'w')
00112         SG_WARNING("Could not write `%s%s' to `%s'!\n", prefix,
00113                    name, m_filename);
00114     if (m_task == 'r')
00115         SG_WARNING("Could not read `%s%s' from `%s'!\n", prefix,
00116                    name, m_filename);
00117     if (m_task != 'w' && m_task != 'r')
00118         SG_WARNING("Could not read/write `%s%s' from `%s'!\n",
00119                    prefix, name, m_filename);
00120 
00121     return false;
00122 }
00123 
00124 bool
00125 CSerializableFile::write_scalar(
00126     const TSGDataType* type, const char* name, const char* prefix,
00127     const void* param)
00128 {
00129     if (!is_task_warn('w', name, prefix)) return false;
00130 
00131     if (!write_scalar_wrapped(type, param))
00132         return false_warn(prefix, name);
00133 
00134     return true;
00135 }
00136 
00137 bool
00138 CSerializableFile::read_scalar(
00139     const TSGDataType* type, const char* name, const char* prefix,
00140     void* param)
00141 {
00142     if (!is_task_warn('r', name, prefix)) return false;
00143 
00144     if (!m_reader->read_scalar_wrapped(type, param))
00145         return false_warn(prefix, name);
00146 
00147     return true;
00148 }
00149 
00150 bool
00151 CSerializableFile::write_cont_begin(
00152     const TSGDataType* type, const char* name, const char* prefix,
00153     index_t len_real_y, index_t len_real_x)
00154 {
00155     if (!is_task_warn('w', name, prefix)) return false;
00156 
00157     if (!write_cont_begin_wrapped(type, len_real_y, len_real_x))
00158         return false_warn(prefix, name);
00159 
00160     return true;
00161 }
00162 
00163 bool
00164 CSerializableFile::read_cont_begin(
00165     const TSGDataType* type, const char* name, const char* prefix,
00166     index_t* len_read_y, index_t* len_read_x)
00167 {
00168     if (!is_task_warn('r', name, prefix)) return false;
00169 
00170     if (!m_reader->read_cont_begin_wrapped(type, len_read_y,
00171                                            len_read_x))
00172         return false_warn(prefix, name);
00173 
00174     return true;
00175 }
00176 
00177 bool
00178 CSerializableFile::write_cont_end(
00179     const TSGDataType* type, const char* name, const char* prefix,
00180     index_t len_real_y, index_t len_real_x)
00181 {
00182     if (!is_task_warn('w', name, prefix)) return false;
00183 
00184     if (!write_cont_end_wrapped(type, len_real_y, len_real_x))
00185         return false_warn(prefix, name);
00186 
00187     return true;
00188 }
00189 
00190 bool
00191 CSerializableFile::read_cont_end(
00192     const TSGDataType* type, const char* name, const char* prefix,
00193     index_t len_read_y, index_t len_read_x)
00194 {
00195     if (!is_task_warn('r', name, prefix)) return false;
00196 
00197     if (!m_reader->read_cont_end_wrapped(type, len_read_y, len_read_x))
00198         return false_warn(prefix, name);
00199 
00200     return true;
00201 }
00202 
00203 bool
00204 CSerializableFile::write_string_begin(
00205     const TSGDataType* type, const char* name, const char* prefix,
00206     index_t length)
00207 {
00208     if (!is_task_warn('w', name, prefix)) return false;
00209 
00210     if (!write_string_begin_wrapped(type, length))
00211         return false_warn(prefix, name);
00212 
00213     return true;
00214 }
00215 
00216 bool
00217 CSerializableFile::read_string_begin(
00218     const TSGDataType* type, const char* name, const char* prefix,
00219     index_t* length)
00220 {
00221     if (!is_task_warn('r', name, prefix)) return false;
00222 
00223     if (!m_reader->read_string_begin_wrapped(type, length))
00224         return false_warn(prefix, name);
00225 
00226     return true;
00227 }
00228 
00229 bool
00230 CSerializableFile::write_string_end(
00231     const TSGDataType* type, const char* name, const char* prefix,
00232     index_t length)
00233 {
00234     if (!is_task_warn('w', name, prefix)) return false;
00235 
00236     if (!write_string_end_wrapped(type, length))
00237         return false_warn(prefix, name);
00238 
00239     return true;
00240 }
00241 
00242 bool
00243 CSerializableFile::read_string_end(
00244     const TSGDataType* type, const char* name, const char* prefix,
00245     index_t length)
00246 {
00247     if (!is_task_warn('r', name, prefix)) return false;
00248 
00249     if (!m_reader->read_string_end_wrapped(type, length))
00250         return false_warn(prefix, name);
00251 
00252     return true;
00253 }
00254 
00255 bool
00256 CSerializableFile::write_stringentry_begin(
00257     const TSGDataType* type, const char* name, const char* prefix,
00258     index_t y)
00259 {
00260     if (!is_task_warn('w', name, prefix)) return false;
00261 
00262     if (!write_stringentry_begin_wrapped(type, y))
00263         return false_warn(prefix, name);
00264 
00265     return true;
00266 }
00267 
00268 bool
00269 CSerializableFile::read_stringentry_begin(
00270     const TSGDataType* type, const char* name, const char* prefix,
00271     index_t y)
00272 {
00273     if (!is_task_warn('r', name, prefix)) return false;
00274 
00275     if (!m_reader->read_stringentry_begin_wrapped(type, y))
00276         return false_warn(prefix, name);
00277 
00278     return true;
00279 }
00280 
00281 bool
00282 CSerializableFile::write_stringentry_end(
00283     const TSGDataType* type, const char* name, const char* prefix,
00284     index_t y)
00285 {
00286     if (!is_task_warn('w', name, prefix)) return false;
00287 
00288     if (!write_stringentry_end_wrapped(type, y))
00289         return false_warn(prefix, name);
00290 
00291     return true;
00292 }
00293 
00294 bool
00295 CSerializableFile::read_stringentry_end(
00296     const TSGDataType* type, const char* name, const char* prefix,
00297     index_t y)
00298 {
00299     if (!is_task_warn('r', name, prefix)) return false;
00300 
00301     if (!m_reader->read_stringentry_end_wrapped(type, y))
00302         return false_warn(prefix, name);
00303 
00304     return true;
00305 }
00306 
00307 bool
00308 CSerializableFile::write_sparse_begin(
00309     const TSGDataType* type, const char* name, const char* prefix,
00310     index_t vec_index, index_t length)
00311 {
00312     if (!is_task_warn('w', name, prefix)) return false;
00313 
00314     if (!write_sparse_begin_wrapped(type, vec_index, length))
00315         return false_warn(prefix, name);
00316 
00317     return true;
00318 }
00319 
00320 bool
00321 CSerializableFile::read_sparse_begin(
00322     const TSGDataType* type, const char* name, const char* prefix,
00323     index_t* vec_index, index_t* length)
00324 {
00325     if (!is_task_warn('r', name, prefix)) return false;
00326 
00327     if (!m_reader->read_sparse_begin_wrapped(type, vec_index, length))
00328         return false_warn(prefix, name);
00329 
00330     return true;
00331 }
00332 
00333 bool
00334 CSerializableFile::write_sparse_end(
00335     const TSGDataType* type, const char* name, const char* prefix,
00336     index_t vec_index, index_t length)
00337 {
00338     if (!is_task_warn('w', name, prefix)) return false;
00339 
00340     if (!write_sparse_end_wrapped(type, vec_index, length))
00341         return false_warn(prefix, name);
00342 
00343     return true;
00344 }
00345 
00346 bool
00347 CSerializableFile::read_sparse_end(
00348     const TSGDataType* type, const char* name, const char* prefix,
00349     index_t* vec_index, index_t length)
00350 {
00351     if (!is_task_warn('r', name, prefix)) return false;
00352 
00353     if (!m_reader->read_sparse_end_wrapped(type, vec_index, length))
00354         return false_warn(prefix, name);
00355 
00356     return true;
00357 }
00358 
00359 bool
00360 CSerializableFile::write_sparseentry_begin(
00361     const TSGDataType* type, const char* name, const char* prefix,
00362     const SGSparseVectorEntry<char>* first_entry, index_t feat_index,
00363     index_t y)
00364 {
00365     if (!is_task_warn('w', name, prefix)) return false;
00366 
00367     if (!write_sparseentry_begin_wrapped(type, first_entry,
00368                                          feat_index, y))
00369         return false_warn(prefix, name);
00370 
00371     return true;
00372 }
00373 
00374 bool
00375 CSerializableFile::read_sparseentry_begin(
00376     const TSGDataType* type, const char* name, const char* prefix,
00377     SGSparseVectorEntry<char>* first_entry, index_t* feat_index, index_t y)
00378 {
00379     if (!is_task_warn('r', name, prefix)) return false;
00380 
00381     if (!m_reader->read_sparseentry_begin_wrapped(type, first_entry,
00382                                                   feat_index, y))
00383         return false_warn(prefix, name);
00384 
00385     return true;
00386 }
00387 
00388 bool
00389 CSerializableFile::write_sparseentry_end(
00390     const TSGDataType* type, const char* name, const char* prefix,
00391     const SGSparseVectorEntry<char>* first_entry, index_t feat_index,
00392     index_t y)
00393 {
00394     if (!is_task_warn('w', name, prefix)) return false;
00395 
00396     if (!write_sparseentry_end_wrapped(type, first_entry, feat_index,
00397                                        y))
00398         return false_warn(prefix, name);
00399 
00400     return true;
00401 }
00402 
00403 bool
00404 CSerializableFile::read_sparseentry_end(
00405     const TSGDataType* type, const char* name, const char* prefix,
00406     SGSparseVectorEntry<char>* first_entry, index_t* feat_index,
00407     index_t y)
00408 {
00409     if (!is_task_warn('r', name, prefix)) return false;
00410 
00411     if (!m_reader->read_sparseentry_end_wrapped(type, first_entry,
00412                                                 feat_index, y))
00413         return false_warn(prefix, name);
00414 
00415     return true;
00416 }
00417 
00418 bool
00419 CSerializableFile::write_item_begin(
00420     const TSGDataType* type, const char* name, const char* prefix,
00421     index_t y, index_t x)
00422 {
00423     if (!is_task_warn('w', name, prefix)) return false;
00424 
00425     if (!write_item_begin_wrapped(type, y, x))
00426         return false_warn(prefix, name);
00427 
00428     return true;
00429 }
00430 
00431 bool
00432 CSerializableFile::read_item_begin(
00433     const TSGDataType* type, const char* name, const char* prefix,
00434     index_t y, index_t x)
00435 {
00436     if (!is_task_warn('r', name, prefix)) return false;
00437 
00438     if (!m_reader->read_item_begin_wrapped(type, y, x))
00439         return false_warn(prefix, name);
00440 
00441     return true;
00442 }
00443 
00444 bool
00445 CSerializableFile::write_item_end(
00446     const TSGDataType* type, const char* name, const char* prefix,
00447     index_t y, index_t x)
00448 {
00449     if (!is_task_warn('w', name, prefix)) return false;
00450 
00451     if (!write_item_end_wrapped(type, y, x))
00452         return false_warn(prefix, name);
00453 
00454     return true;
00455 }
00456 
00457 bool
00458 CSerializableFile::read_item_end(
00459     const TSGDataType* type, const char* name, const char* prefix,
00460     index_t y, index_t x)
00461 {
00462     if (!is_task_warn('r', name, prefix)) return false;
00463 
00464     if (!m_reader->read_item_end_wrapped(type, y, x))
00465         return false_warn(prefix, name);
00466 
00467     return true;
00468 }
00469 
00470 bool
00471 CSerializableFile::write_sgserializable_begin(
00472     const TSGDataType* type, const char* name, const char* prefix,
00473     const char* sgserializable_name, EPrimitiveType generic)
00474 {
00475     if (!is_task_warn('w', name, prefix)) return false;
00476 
00477     if (!write_sgserializable_begin_wrapped(type, sgserializable_name,
00478                                             generic))
00479         return false_warn(prefix, name);
00480 
00481     return true;
00482 }
00483 
00484 bool
00485 CSerializableFile::read_sgserializable_begin(
00486     const TSGDataType* type, const char* name, const char* prefix,
00487     char* sgserializable_name, EPrimitiveType* generic)
00488 {
00489     if (!is_task_warn('r', name, prefix)) return false;
00490 
00491     if (!m_reader->read_sgserializable_begin_wrapped(
00492             type, sgserializable_name, generic))
00493         return false_warn(prefix, name);
00494 
00495     return true;
00496 }
00497 
00498 bool
00499 CSerializableFile::write_sgserializable_end(
00500     const TSGDataType* type, const char* name, const char* prefix,
00501     const char* sgserializable_name, EPrimitiveType generic)
00502 {
00503     if (!is_task_warn('w', name, prefix)) return false;
00504 
00505     if (!write_sgserializable_end_wrapped(type, sgserializable_name,
00506                                           generic))
00507         return false_warn(prefix, name);
00508 
00509     return true;
00510 }
00511 
00512 bool
00513 CSerializableFile::read_sgserializable_end(
00514     const TSGDataType* type, const char* name, const char* prefix,
00515     const char* sgserializable_name, EPrimitiveType generic)
00516 {
00517     if (!is_task_warn('r', name, prefix)) return false;
00518 
00519     if (!m_reader->read_sgserializable_end_wrapped(
00520             type, sgserializable_name, generic))
00521         return false_warn(prefix, name);
00522 
00523     return true;
00524 }
00525 
00526 bool
00527 CSerializableFile::write_type_begin(
00528     const TSGDataType* type, const char* name, const char* prefix)
00529 {
00530     if (!is_task_warn('w', name, prefix)) return false;
00531 
00532     if (!write_type_begin_wrapped(type, name, prefix))
00533         return false_warn(prefix, name);
00534 
00535     return true;
00536 }
00537 
00538 bool
00539 CSerializableFile::read_type_begin(
00540     const TSGDataType* type, const char* name, const char* prefix)
00541 {
00542     if (!is_task_warn('r', name, prefix)) return false;
00543 
00544     if (!m_reader->read_type_begin_wrapped(type, name, prefix))
00545         return false_warn(prefix, name);
00546 
00547     return true;
00548 }
00549 
00550 bool
00551 CSerializableFile::write_type_end(
00552     const TSGDataType* type, const char* name, const char* prefix)
00553 {
00554     if (!is_task_warn('w', name, prefix)) return false;
00555 
00556     if (!write_type_end_wrapped(type, name, prefix))
00557         return false_warn(prefix, name);
00558 
00559     return true;
00560 }
00561 
00562 bool
00563 CSerializableFile::read_type_end(
00564     const TSGDataType* type, const char* name, const char* prefix)
00565 {
00566     if (!is_task_warn('r', name, prefix)) return false;
00567 
00568     if (!m_reader->read_type_end_wrapped(type, name, prefix))
00569         return false_warn(prefix, name);
00570 
00571     return true;
00572 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation