SHOGUN  v1.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SerializableFile.cpp
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 3 of the License, or
5  * (at your option) any later version.
6  *
7  * Written (W) 1999-2010 Soeren Sonnenburg
8  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
9  * Copyright (C) 2010 Berlin Institute of Technology
10  */
11 
13 
14 using namespace shogun;
15 
17  :CSGObject()
18 {
19  init(NULL, 0, "(file)");
20 }
21 
22 CSerializableFile::CSerializableFile(FILE* fstream, char rw)
23  :CSGObject()
24 {
25  init(fstream, rw, "(file)");
26 }
27 
28 CSerializableFile::CSerializableFile(const char* fname, char rw)
29  :CSGObject()
30 {
31  char mode[3] = {rw, 'b', '\0'};
32 
33  init(NULL, rw, fname);
34 
35  if (m_filename == NULL || *m_filename == '\0') {
36  SG_WARNING("Filename not given for opening file!\n");
37  close(); return;
38  }
39 
40  if (rw != 'r' && rw != 'w') {
41  SG_WARNING("Unknown mode '%c'!\n", mode[0]);
42  close(); return;
43  }
44 
45  m_fstream = fopen(m_filename, mode);
46  if (!is_opened()) {
47  SG_WARNING("Error opening file '%s'\n", m_filename);
48  close(); return;
49  }
50 }
51 
53 {
54  close();
56  delete m_reader;
57  m_task = 0;
58 }
59 
60 void
61 CSerializableFile::init(FILE* fstream, char task, const char* filename)
62 {
63  m_fstream = fstream; m_task = task; m_filename = strdup(filename);
64  m_reader = NULL;
65 }
66 
67 void
69 {
70  if (is_opened()) { fclose(m_fstream); m_fstream = NULL; }
71 }
72 
73 bool
75 {
76  return m_fstream != NULL;
77 }
78 
79 bool
80 CSerializableFile::is_task_warn(char rw, const char* name,
81  const char* prefix)
82 {
83  if (m_task == 'r' && m_reader == NULL) {
84  string_t dest_version;
85  strncpy(dest_version, "(unkown)", STRING_LEN);
86  m_reader = new_reader(dest_version, STRING_LEN);
87  if (m_reader == NULL) {
88  SG_WARNING("`%s' has file-version `%s', which is not "
89  "supported!\n", m_filename, dest_version);
90  close(); return false;
91  }
92  }
93 
94  if (rw == 'w' && (m_task != 'w' || !is_opened())) {
95  SG_WARNING("`%s' not opened (for writing) during writing "
96  "`%s%s'!\n", m_filename, prefix, name);
97  return false;
98  }
99  if (rw == 'r' && (m_task != 'r' || !is_opened())) {
100  SG_WARNING("`%s' not opened (for reading) during reading "
101  "`%s%s'!\n", m_filename, prefix, name);
102  return false;
103  }
104 
105  return true;
106 }
107 
108 bool
109 CSerializableFile::false_warn(const char* prefix, const char* name)
110 {
111  if (m_task == 'w')
112  SG_WARNING("Could not write `%s%s' to `%s'!\n", prefix,
113  name, m_filename);
114  if (m_task == 'r')
115  SG_WARNING("Could not read `%s%s' from `%s'!\n", prefix,
116  name, m_filename);
117  if (m_task != 'w' && m_task != 'r')
118  SG_WARNING("Could not read/write `%s%s' from `%s'!\n",
119  prefix, name, m_filename);
120 
121  return false;
122 }
123 
124 bool
125 CSerializableFile::write_scalar(
126  const TSGDataType* type, const char* name, const char* prefix,
127  const void* param)
128 {
129  if (!is_task_warn('w', name, prefix)) return false;
130 
131  if (!write_scalar_wrapped(type, param))
132  return false_warn(prefix, name);
133 
134  return true;
135 }
136 
137 bool
138 CSerializableFile::read_scalar(
139  const TSGDataType* type, const char* name, const char* prefix,
140  void* param)
141 {
142  if (!is_task_warn('r', name, prefix)) return false;
143 
144  if (!m_reader->read_scalar_wrapped(type, param))
145  return false_warn(prefix, name);
146 
147  return true;
148 }
149 
150 bool
151 CSerializableFile::write_cont_begin(
152  const TSGDataType* type, const char* name, const char* prefix,
153  index_t len_real_y, index_t len_real_x)
154 {
155  if (!is_task_warn('w', name, prefix)) return false;
156 
157  if (!write_cont_begin_wrapped(type, len_real_y, len_real_x))
158  return false_warn(prefix, name);
159 
160  return true;
161 }
162 
163 bool
164 CSerializableFile::read_cont_begin(
165  const TSGDataType* type, const char* name, const char* prefix,
166  index_t* len_read_y, index_t* len_read_x)
167 {
168  if (!is_task_warn('r', name, prefix)) return false;
169 
170  if (!m_reader->read_cont_begin_wrapped(type, len_read_y,
171  len_read_x))
172  return false_warn(prefix, name);
173 
174  return true;
175 }
176 
177 bool
178 CSerializableFile::write_cont_end(
179  const TSGDataType* type, const char* name, const char* prefix,
180  index_t len_real_y, index_t len_real_x)
181 {
182  if (!is_task_warn('w', name, prefix)) return false;
183 
184  if (!write_cont_end_wrapped(type, len_real_y, len_real_x))
185  return false_warn(prefix, name);
186 
187  return true;
188 }
189 
190 bool
191 CSerializableFile::read_cont_end(
192  const TSGDataType* type, const char* name, const char* prefix,
193  index_t len_read_y, index_t len_read_x)
194 {
195  if (!is_task_warn('r', name, prefix)) return false;
196 
197  if (!m_reader->read_cont_end_wrapped(type, len_read_y, len_read_x))
198  return false_warn(prefix, name);
199 
200  return true;
201 }
202 
203 bool
204 CSerializableFile::write_string_begin(
205  const TSGDataType* type, const char* name, const char* prefix,
206  index_t length)
207 {
208  if (!is_task_warn('w', name, prefix)) return false;
209 
210  if (!write_string_begin_wrapped(type, length))
211  return false_warn(prefix, name);
212 
213  return true;
214 }
215 
216 bool
217 CSerializableFile::read_string_begin(
218  const TSGDataType* type, const char* name, const char* prefix,
219  index_t* length)
220 {
221  if (!is_task_warn('r', name, prefix)) return false;
222 
223  if (!m_reader->read_string_begin_wrapped(type, length))
224  return false_warn(prefix, name);
225 
226  return true;
227 }
228 
229 bool
230 CSerializableFile::write_string_end(
231  const TSGDataType* type, const char* name, const char* prefix,
232  index_t length)
233 {
234  if (!is_task_warn('w', name, prefix)) return false;
235 
236  if (!write_string_end_wrapped(type, length))
237  return false_warn(prefix, name);
238 
239  return true;
240 }
241 
242 bool
243 CSerializableFile::read_string_end(
244  const TSGDataType* type, const char* name, const char* prefix,
245  index_t length)
246 {
247  if (!is_task_warn('r', name, prefix)) return false;
248 
249  if (!m_reader->read_string_end_wrapped(type, length))
250  return false_warn(prefix, name);
251 
252  return true;
253 }
254 
255 bool
256 CSerializableFile::write_stringentry_begin(
257  const TSGDataType* type, const char* name, const char* prefix,
258  index_t y)
259 {
260  if (!is_task_warn('w', name, prefix)) return false;
261 
262  if (!write_stringentry_begin_wrapped(type, y))
263  return false_warn(prefix, name);
264 
265  return true;
266 }
267 
268 bool
269 CSerializableFile::read_stringentry_begin(
270  const TSGDataType* type, const char* name, const char* prefix,
271  index_t y)
272 {
273  if (!is_task_warn('r', name, prefix)) return false;
274 
275  if (!m_reader->read_stringentry_begin_wrapped(type, y))
276  return false_warn(prefix, name);
277 
278  return true;
279 }
280 
281 bool
282 CSerializableFile::write_stringentry_end(
283  const TSGDataType* type, const char* name, const char* prefix,
284  index_t y)
285 {
286  if (!is_task_warn('w', name, prefix)) return false;
287 
288  if (!write_stringentry_end_wrapped(type, y))
289  return false_warn(prefix, name);
290 
291  return true;
292 }
293 
294 bool
295 CSerializableFile::read_stringentry_end(
296  const TSGDataType* type, const char* name, const char* prefix,
297  index_t y)
298 {
299  if (!is_task_warn('r', name, prefix)) return false;
300 
301  if (!m_reader->read_stringentry_end_wrapped(type, y))
302  return false_warn(prefix, name);
303 
304  return true;
305 }
306 
307 bool
308 CSerializableFile::write_sparse_begin(
309  const TSGDataType* type, const char* name, const char* prefix,
310  index_t vec_index, index_t length)
311 {
312  if (!is_task_warn('w', name, prefix)) return false;
313 
314  if (!write_sparse_begin_wrapped(type, vec_index, length))
315  return false_warn(prefix, name);
316 
317  return true;
318 }
319 
320 bool
321 CSerializableFile::read_sparse_begin(
322  const TSGDataType* type, const char* name, const char* prefix,
323  index_t* vec_index, index_t* length)
324 {
325  if (!is_task_warn('r', name, prefix)) return false;
326 
327  if (!m_reader->read_sparse_begin_wrapped(type, vec_index, length))
328  return false_warn(prefix, name);
329 
330  return true;
331 }
332 
333 bool
334 CSerializableFile::write_sparse_end(
335  const TSGDataType* type, const char* name, const char* prefix,
336  index_t vec_index, index_t length)
337 {
338  if (!is_task_warn('w', name, prefix)) return false;
339 
340  if (!write_sparse_end_wrapped(type, vec_index, length))
341  return false_warn(prefix, name);
342 
343  return true;
344 }
345 
346 bool
347 CSerializableFile::read_sparse_end(
348  const TSGDataType* type, const char* name, const char* prefix,
349  index_t* vec_index, index_t length)
350 {
351  if (!is_task_warn('r', name, prefix)) return false;
352 
353  if (!m_reader->read_sparse_end_wrapped(type, vec_index, length))
354  return false_warn(prefix, name);
355 
356  return true;
357 }
358 
359 bool
360 CSerializableFile::write_sparseentry_begin(
361  const TSGDataType* type, const char* name, const char* prefix,
362  const SGSparseVectorEntry<char>* first_entry, index_t feat_index,
363  index_t y)
364 {
365  if (!is_task_warn('w', name, prefix)) return false;
366 
367  if (!write_sparseentry_begin_wrapped(type, first_entry,
368  feat_index, y))
369  return false_warn(prefix, name);
370 
371  return true;
372 }
373 
374 bool
375 CSerializableFile::read_sparseentry_begin(
376  const TSGDataType* type, const char* name, const char* prefix,
377  SGSparseVectorEntry<char>* first_entry, index_t* feat_index, index_t y)
378 {
379  if (!is_task_warn('r', name, prefix)) return false;
380 
381  if (!m_reader->read_sparseentry_begin_wrapped(type, first_entry,
382  feat_index, y))
383  return false_warn(prefix, name);
384 
385  return true;
386 }
387 
388 bool
389 CSerializableFile::write_sparseentry_end(
390  const TSGDataType* type, const char* name, const char* prefix,
391  const SGSparseVectorEntry<char>* first_entry, index_t feat_index,
392  index_t y)
393 {
394  if (!is_task_warn('w', name, prefix)) return false;
395 
396  if (!write_sparseentry_end_wrapped(type, first_entry, feat_index,
397  y))
398  return false_warn(prefix, name);
399 
400  return true;
401 }
402 
403 bool
404 CSerializableFile::read_sparseentry_end(
405  const TSGDataType* type, const char* name, const char* prefix,
406  SGSparseVectorEntry<char>* first_entry, index_t* feat_index,
407  index_t y)
408 {
409  if (!is_task_warn('r', name, prefix)) return false;
410 
411  if (!m_reader->read_sparseentry_end_wrapped(type, first_entry,
412  feat_index, y))
413  return false_warn(prefix, name);
414 
415  return true;
416 }
417 
418 bool
419 CSerializableFile::write_item_begin(
420  const TSGDataType* type, const char* name, const char* prefix,
421  index_t y, index_t x)
422 {
423  if (!is_task_warn('w', name, prefix)) return false;
424 
425  if (!write_item_begin_wrapped(type, y, x))
426  return false_warn(prefix, name);
427 
428  return true;
429 }
430 
431 bool
432 CSerializableFile::read_item_begin(
433  const TSGDataType* type, const char* name, const char* prefix,
434  index_t y, index_t x)
435 {
436  if (!is_task_warn('r', name, prefix)) return false;
437 
438  if (!m_reader->read_item_begin_wrapped(type, y, x))
439  return false_warn(prefix, name);
440 
441  return true;
442 }
443 
444 bool
445 CSerializableFile::write_item_end(
446  const TSGDataType* type, const char* name, const char* prefix,
447  index_t y, index_t x)
448 {
449  if (!is_task_warn('w', name, prefix)) return false;
450 
451  if (!write_item_end_wrapped(type, y, x))
452  return false_warn(prefix, name);
453 
454  return true;
455 }
456 
457 bool
458 CSerializableFile::read_item_end(
459  const TSGDataType* type, const char* name, const char* prefix,
460  index_t y, index_t x)
461 {
462  if (!is_task_warn('r', name, prefix)) return false;
463 
464  if (!m_reader->read_item_end_wrapped(type, y, x))
465  return false_warn(prefix, name);
466 
467  return true;
468 }
469 
470 bool
471 CSerializableFile::write_sgserializable_begin(
472  const TSGDataType* type, const char* name, const char* prefix,
473  const char* sgserializable_name, EPrimitiveType generic)
474 {
475  if (!is_task_warn('w', name, prefix)) return false;
476 
477  if (!write_sgserializable_begin_wrapped(type, sgserializable_name,
478  generic))
479  return false_warn(prefix, name);
480 
481  return true;
482 }
483 
484 bool
485 CSerializableFile::read_sgserializable_begin(
486  const TSGDataType* type, const char* name, const char* prefix,
487  char* sgserializable_name, EPrimitiveType* generic)
488 {
489  if (!is_task_warn('r', name, prefix)) return false;
490 
491  if (!m_reader->read_sgserializable_begin_wrapped(
492  type, sgserializable_name, generic))
493  return false_warn(prefix, name);
494 
495  return true;
496 }
497 
498 bool
499 CSerializableFile::write_sgserializable_end(
500  const TSGDataType* type, const char* name, const char* prefix,
501  const char* sgserializable_name, EPrimitiveType generic)
502 {
503  if (!is_task_warn('w', name, prefix)) return false;
504 
505  if (!write_sgserializable_end_wrapped(type, sgserializable_name,
506  generic))
507  return false_warn(prefix, name);
508 
509  return true;
510 }
511 
512 bool
513 CSerializableFile::read_sgserializable_end(
514  const TSGDataType* type, const char* name, const char* prefix,
515  const char* sgserializable_name, EPrimitiveType generic)
516 {
517  if (!is_task_warn('r', name, prefix)) return false;
518 
519  if (!m_reader->read_sgserializable_end_wrapped(
520  type, sgserializable_name, generic))
521  return false_warn(prefix, name);
522 
523  return true;
524 }
525 
526 bool
527 CSerializableFile::write_type_begin(
528  const TSGDataType* type, const char* name, const char* prefix)
529 {
530  if (!is_task_warn('w', name, prefix)) return false;
531 
532  if (!write_type_begin_wrapped(type, name, prefix))
533  return false_warn(prefix, name);
534 
535  return true;
536 }
537 
538 bool
539 CSerializableFile::read_type_begin(
540  const TSGDataType* type, const char* name, const char* prefix)
541 {
542  if (!is_task_warn('r', name, prefix)) return false;
543 
544  if (!m_reader->read_type_begin_wrapped(type, name, prefix))
545  return false_warn(prefix, name);
546 
547  return true;
548 }
549 
550 bool
551 CSerializableFile::write_type_end(
552  const TSGDataType* type, const char* name, const char* prefix)
553 {
554  if (!is_task_warn('w', name, prefix)) return false;
555 
556  if (!write_type_end_wrapped(type, name, prefix))
557  return false_warn(prefix, name);
558 
559  return true;
560 }
561 
562 bool
563 CSerializableFile::read_type_end(
564  const TSGDataType* type, const char* name, const char* prefix)
565 {
566  if (!is_task_warn('r', name, prefix)) return false;
567 
568  if (!m_reader->read_type_end_wrapped(type, name, prefix))
569  return false_warn(prefix, name);
570 
571  return true;
572 }

SHOGUN Machine Learning Toolbox - Documentation