00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include <shogun/io/SerializableFile.h>
00013
00014 using namespace shogun;
00015
00016 CSerializableFile::CSerializableFile(void)
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(void)
00069 {
00070 if (is_opened()) { fclose(m_fstream); m_fstream = NULL; }
00071 }
00072
00073 bool
00074 CSerializableFile::is_opened(void)
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 }