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

SHOGUN Machine Learning Toolbox - Documentation