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

SHOGUN Machine Learning Toolbox - Documentation