SHOGUN  v2.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
BinaryFile.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) 2010 Soeren Sonnenburg
8  * Copyright (C) 2010 Berlin Institute of Technology
9  */
10 
11 #include <shogun/io/File.h>
12 #include <shogun/features/SparseFeatures.h>
13 #include <shogun/io/BinaryFile.h>
14 
15 using namespace shogun;
16 
17 CBinaryFile::CBinaryFile()
18 {
19  SG_UNSTABLE("CBinaryFile::CBinaryFile()", "\n");
20 }
21 
22 CBinaryFile::CBinaryFile(FILE* f, const char* name) : CFile(f, name)
23 {
24 }
25 
26 CBinaryFile::CBinaryFile(const char* fname, char rw, const char* name) : CFile(fname, rw, name)
27 {
28 }
29 
30 CBinaryFile::~CBinaryFile()
31 {
32 }
33 
34 #define GET_VECTOR(fname, sg_type, datatype) \
35 void CBinaryFile::fname(sg_type*& vec, int32_t& len) \
36 { \
37  if (!file) \
38  SG_ERROR("File invalid.\n"); \
39  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
40  if (dtype!=datatype) \
41  SG_ERROR("Datatype mismatch\n"); \
42  \
43  if (fread(&len, sizeof(int32_t), 1, file)!=1) \
44  SG_ERROR("Failed to read vector length\n"); \
45  vec=SG_MALLOC(sg_type, len); \
46  if (fread(vec, sizeof(sg_type), len, file)!=(size_t) len) \
47  SG_ERROR("Failed to read Matrix\n"); \
48 }
49 
50 GET_VECTOR(get_vector, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
51 GET_VECTOR(get_vector, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
52 GET_VECTOR(get_vector, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
53 GET_VECTOR(get_vector, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
54 GET_VECTOR(get_vector, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
55 GET_VECTOR(get_vector, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
56 GET_VECTOR(get_vector, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
57 #undef GET_VECTOR
58 
59 #define GET_MATRIX(fname, sg_type, datatype) \
60 void CBinaryFile::fname(sg_type*& matrix, int32_t& num_feat, int32_t& num_vec) \
61 { \
62  if (!file) \
63  SG_ERROR("File invalid.\n"); \
64  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
65  if (dtype!=datatype) \
66  SG_ERROR("Datatype mismatch\n"); \
67  \
68  if (fread(&num_feat, sizeof(int32_t), 1, file)!=1 || \
69  fread(&num_vec, sizeof(int32_t), 1, file)!=1) \
70  SG_ERROR("Failed to read Matrix dimensions\n"); \
71  matrix=SG_MALLOC(sg_type, int64_t(num_feat)*num_vec); \
72  if (fread(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec) \
73  SG_ERROR("Failed to read Matrix\n"); \
74 }
75 
76 GET_MATRIX(get_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
77 GET_MATRIX(get_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
78 GET_MATRIX(get_int8_matrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
79 GET_MATRIX(get_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
80 GET_MATRIX(get_uint_matrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
81 GET_MATRIX(get_long_matrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
82 GET_MATRIX(get_ulong_matrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
83 GET_MATRIX(get_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
84 GET_MATRIX(get_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
85 GET_MATRIX(get_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
86 GET_MATRIX(get_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
87 GET_MATRIX(get_longreal_matrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
88 #undef GET_MATRIX
89 
90 #define GET_NDARRAY(fname,sg_type,datatype) \
91 void CBinaryFile::fname(sg_type *& array, int32_t *& dims,int32_t & num_dims)\
92 { \
93  size_t total = 1; \
94  \
95  if (!file) \
96  SG_ERROR("File invalid.\n"); \
97  \
98  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); \
99  read_header(&dtype); \
100  \
101  if (dtype!=datatype) \
102  SG_ERROR("Datatype mismatch\n"); \
103  \
104  if (fread(&num_dims,sizeof(int32_t),1,file) != 1) \
105  SG_ERROR("Failed to read number of dimensions"); \
106  \
107  dims = SG_MALLOC(int32_t, num_dims); \
108  if (fread(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims) \
109  SG_ERROR("Failed to read sizes of dimensions!"); \
110  \
111  for (int32_t i = 0;i < num_dims;i++) \
112  total *= dims[i]; \
113  \
114  array = SG_MALLOC(sg_type, total); \
115  if (fread(array,sizeof(sg_type),total,file) != (size_t)total) \
116  SG_ERROR("Failed to read array data!"); \
117 }
118 
119 GET_NDARRAY(get_ndarray,uint8_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT8));
120 GET_NDARRAY(get_ndarray,char,TSGDataType(CT_NDARRAY, ST_NONE, PT_CHAR));
121 GET_NDARRAY(get_ndarray,int32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT32));
122 GET_NDARRAY(get_ndarray,int16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT16));
123 GET_NDARRAY(get_ndarray,uint16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT16));
124 GET_NDARRAY(get_ndarray,float32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT32));
125 GET_NDARRAY(get_ndarray,float64_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT64));
126 #undef GET_NDARRAY
127 
128 #define GET_SPARSEMATRIX(fname, sg_type, datatype) \
129 void CBinaryFile::fname(SGSparseVector<sg_type>*& matrix, int32_t& num_feat, int32_t& num_vec) \
130 { \
131  if (!(file)) \
132  SG_ERROR("File invalid.\n"); \
133  \
134  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
135  if (dtype!=datatype) \
136  SG_ERROR("Datatype mismatch\n"); \
137  \
138  if (fread(&num_vec, sizeof(int32_t), 1, file)!=1) \
139  SG_ERROR("Failed to read number of vectors\n"); \
140  \
141  matrix=SG_MALLOC(SGSparseVector<sg_type>, num_vec); \
142  \
143  for (int32_t i=0; i<num_vec; i++) \
144  { \
145  new (&matrix[i]) SGSparseVector<sg_type>(); \
146  int32_t len=0; \
147  if (fread(&len, sizeof(int32_t), 1, file)!=1) \
148  SG_ERROR("Failed to read sparse vector length of vector idx=%d\n", i); \
149  matrix[i].num_feat_entries=len; \
150  SGSparseVectorEntry<sg_type>* vec = SG_MALLOC(SGSparseVectorEntry<sg_type>, len); \
151  if (fread(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len) \
152  SG_ERROR("Failed to read sparse vector %d\n", i); \
153  matrix[i].features=vec; \
154  } \
155 }
156 GET_SPARSEMATRIX(get_sparse_matrix, bool, TSGDataType(CT_MATRIX, ST_NONE, PT_BOOL))
157 GET_SPARSEMATRIX(get_sparse_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
158 GET_SPARSEMATRIX(get_sparse_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
159 GET_SPARSEMATRIX(get_int8_sparsematrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
160 GET_SPARSEMATRIX(get_sparse_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
161 GET_SPARSEMATRIX(get_uint_sparsematrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
162 GET_SPARSEMATRIX(get_long_sparsematrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
163 GET_SPARSEMATRIX(get_ulong_sparsematrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
164 GET_SPARSEMATRIX(get_sparse_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
165 GET_SPARSEMATRIX(get_sparse_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
166 GET_SPARSEMATRIX(get_sparse_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
167 GET_SPARSEMATRIX(get_sparse_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
168 GET_SPARSEMATRIX(get_longreal_sparsematrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
169 #undef GET_SPARSEMATRIX
170 
171 
172 #define GET_STRING_LIST(fname, sg_type, datatype) \
173 void CBinaryFile::fname(SGString<sg_type>*& strings, int32_t& num_str, int32_t& max_string_len) \
174 { \
175  strings=NULL; \
176  num_str=0; \
177  max_string_len=0; \
178  \
179  if (!file) \
180  SG_ERROR("File invalid.\n"); \
181  \
182  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
183  if (dtype!=datatype) \
184  SG_ERROR("Datatype mismatch\n"); \
185  \
186  if (fread(&num_str, sizeof(int32_t), 1, file)!=1) \
187  SG_ERROR("Failed to read number of strings\n"); \
188  \
189  strings=SG_MALLOC(SGString<sg_type>, num_str); \
190  \
191  for (int32_t i=0; i<num_str; i++) \
192  { \
193  int32_t len=0; \
194  if (fread(&len, sizeof(int32_t), 1, file)!=1) \
195  SG_ERROR("Failed to read string length of string with idx=%d\n", i); \
196  strings[i].slen=len; \
197  sg_type* str = SG_MALLOC(sg_type, len); \
198  if (fread(str, sizeof(sg_type), len, file)!= (size_t) len) \
199  SG_ERROR("Failed to read string %d\n", i); \
200  strings[i].string=str; \
201  } \
202 }
203 
204 GET_STRING_LIST(get_string_list, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
205 GET_STRING_LIST(get_string_list, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
206 GET_STRING_LIST(get_int8_string_list, int8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT8))
207 GET_STRING_LIST(get_string_list, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
208 GET_STRING_LIST(get_uint_string_list, uint32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
209 GET_STRING_LIST(get_long_string_list, int64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
210 GET_STRING_LIST(get_ulong_string_list, uint64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
211 GET_STRING_LIST(get_string_list, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
212 GET_STRING_LIST(get_string_list, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
213 GET_STRING_LIST(get_string_list, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
214 GET_STRING_LIST(get_string_list, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
215 GET_STRING_LIST(get_longreal_string_list, floatmax_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOATMAX))
216 #undef GET_STRING_LIST
217 
220 #define SET_VECTOR(fname, sg_type, dtype) \
221 void CBinaryFile::fname(const sg_type* vec, int32_t len) \
222 { \
223  if (!(file && vec)) \
224  SG_ERROR("File or vector invalid.\n"); \
225  \
226  TSGDataType t dtype; write_header(&t); \
227  \
228  if (fwrite(&len, sizeof(int32_t), 1, file)!=1 || \
229  fwrite(vec, sizeof(sg_type), len, file)!=(size_t) len) \
230  SG_ERROR("Failed to write vector\n"); \
231 }
232 SET_VECTOR(set_vector, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
233 SET_VECTOR(set_vector, char, (CT_VECTOR, ST_NONE, PT_CHAR))
234 SET_VECTOR(set_vector, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
235 SET_VECTOR(set_vector, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
236 SET_VECTOR(set_vector, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
237 SET_VECTOR(set_vector, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
238 SET_VECTOR(set_vector, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
239 #undef SET_VECTOR
240 
241 #define SET_MATRIX(fname, sg_type, dtype) \
242 void CBinaryFile::fname(const sg_type* matrix, int32_t num_feat, int32_t num_vec) \
243 { \
244  if (!(file && matrix)) \
245  SG_ERROR("File or matrix invalid.\n"); \
246  \
247  TSGDataType t dtype; write_header(&t); \
248  \
249  if (fwrite(&num_feat, sizeof(int32_t), 1, file)!=1 || \
250  fwrite(&num_vec, sizeof(int32_t), 1, file)!=1 || \
251  fwrite(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec) \
252  SG_ERROR("Failed to write Matrix\n"); \
253 }
254 SET_MATRIX(set_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
255 SET_MATRIX(set_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
256 SET_MATRIX(set_int8_matrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
257 SET_MATRIX(set_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
258 SET_MATRIX(set_uint_matrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
259 SET_MATRIX(set_long_matrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
260 SET_MATRIX(set_ulong_matrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
261 SET_MATRIX(set_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
262 SET_MATRIX(set_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
263 SET_MATRIX(set_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
264 SET_MATRIX(set_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
265 SET_MATRIX(set_longreal_matrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
266 #undef SET_MATRIX
267 
268 #define SET_NDARRAY(fname,sg_type,datatype) \
269 void CBinaryFile::fname(const sg_type * array, int32_t * dims,int32_t num_dims) \
270 { \
271  size_t total = 1; \
272  \
273  if (!file) \
274  SG_ERROR("File invalid.\n"); \
275  \
276  if (!array) \
277  SG_ERROR("Invalid array!\n"); \
278  \
279  TSGDataType t datatype; \
280  write_header(&t); \
281  \
282  if (fwrite(&num_dims,sizeof(int32_t),1,file) != 1) \
283  SG_ERROR("Failed to write number of dimensions!\n"); \
284  \
285  if (fwrite(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims) \
286  SG_ERROR("Failed to write sizes of dimensions!\n"); \
287  \
288  for (int32_t i = 0;i < num_dims;i++) \
289  total *= dims[i]; \
290  \
291  if (fwrite(array,sizeof(sg_type),total,file) != (size_t)total) \
292  SG_ERROR("Failed to write array data!\n"); \
293 }
294 
295 SET_NDARRAY(set_ndarray,uint8_t,(CT_NDARRAY, ST_NONE, PT_UINT8));
296 SET_NDARRAY(set_ndarray,char,(CT_NDARRAY, ST_NONE, PT_CHAR));
297 SET_NDARRAY(set_ndarray,int32_t,(CT_NDARRAY, ST_NONE, PT_INT32));
298 SET_NDARRAY(set_ndarray,int16_t,(CT_NDARRAY, ST_NONE, PT_INT16));
299 SET_NDARRAY(set_ndarray,uint16_t,(CT_NDARRAY, ST_NONE, PT_UINT16));
300 SET_NDARRAY(set_ndarray,float32_t,(CT_NDARRAY, ST_NONE, PT_FLOAT32));
301 SET_NDARRAY(set_ndarray,float64_t,(CT_NDARRAY, ST_NONE, PT_FLOAT64));
302 #undef SET_NDARRAY
303 
304 #define SET_SPARSEMATRIX(fname, sg_type, dtype) \
305 void CBinaryFile::fname(const SGSparseVector<sg_type>* matrix, \
306  int32_t num_feat, int32_t num_vec) \
307 { \
308  if (!(file && matrix)) \
309  SG_ERROR("File or matrix invalid.\n"); \
310  \
311  TSGDataType t dtype; write_header(&t); \
312  \
313  if (fwrite(&num_vec, sizeof(int32_t), 1, file)!=1) \
314  SG_ERROR("Failed to write Sparse Matrix\n"); \
315  \
316  for (int32_t i=0; i<num_vec; i++) \
317  { \
318  SGSparseVectorEntry<sg_type>* vec = matrix[i].features; \
319  int32_t len=matrix[i].num_feat_entries; \
320  if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \
321  (fwrite(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len)) \
322  SG_ERROR("Failed to write Sparse Matrix\n"); \
323  } \
324 }
325 SET_SPARSEMATRIX(set_sparse_matrix, bool, (CT_MATRIX, ST_NONE, PT_BOOL))
326 SET_SPARSEMATRIX(set_sparse_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
327 SET_SPARSEMATRIX(set_sparse_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
328 SET_SPARSEMATRIX(set_int8_sparsematrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
329 SET_SPARSEMATRIX(set_sparse_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
330 SET_SPARSEMATRIX(set_uint_sparsematrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
331 SET_SPARSEMATRIX(set_long_sparsematrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
332 SET_SPARSEMATRIX(set_ulong_sparsematrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
333 SET_SPARSEMATRIX(set_sparse_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
334 SET_SPARSEMATRIX(set_sparse_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
335 SET_SPARSEMATRIX(set_sparse_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
336 SET_SPARSEMATRIX(set_sparse_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
337 SET_SPARSEMATRIX(set_longreal_sparsematrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
338 #undef SET_SPARSEMATRIX
339 
340 #define SET_STRING_LIST(fname, sg_type, dtype) \
341 void CBinaryFile::fname(const SGString<sg_type>* strings, int32_t num_str) \
342 { \
343  if (!(file && strings)) \
344  SG_ERROR("File or strings invalid.\n"); \
345  \
346  TSGDataType t dtype; write_header(&t); \
347  for (int32_t i=0; i<num_str; i++) \
348  { \
349  int32_t len = strings[i].slen; \
350  if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \
351  (fwrite(strings[i].string, sizeof(sg_type), len, file)!= (size_t) len)) \
352  SG_ERROR("Failed to write Sparse Matrix\n"); \
353  } \
354 }
355 SET_STRING_LIST(set_string_list, char, (CT_VECTOR, ST_NONE, PT_CHAR))
356 SET_STRING_LIST(set_string_list, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
357 SET_STRING_LIST(set_int8_string_list, int8_t, (CT_VECTOR, ST_NONE, PT_INT8))
358 SET_STRING_LIST(set_string_list, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
359 SET_STRING_LIST(set_uint_string_list, uint32_t, (CT_VECTOR, ST_NONE, PT_INT32))
360 SET_STRING_LIST(set_long_string_list, int64_t, (CT_VECTOR, ST_NONE, PT_INT64))
361 SET_STRING_LIST(set_ulong_string_list, uint64_t, (CT_VECTOR, ST_NONE, PT_INT64))
362 SET_STRING_LIST(set_string_list, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
363 SET_STRING_LIST(set_string_list, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
364 SET_STRING_LIST(set_string_list, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
365 SET_STRING_LIST(set_string_list, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
366 SET_STRING_LIST(set_longreal_string_list, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX))
367 #undef SET_STRING_LIST
368 
369 
370 int32_t CBinaryFile::parse_first_header(TSGDataType& type)
371 {
372  return -1;
373 }
374 
375 int32_t CBinaryFile::parse_next_header(TSGDataType& type)
376 {
377  return -1;
378 }
379 
380 void
381 CBinaryFile::read_header(TSGDataType* dest)
382 {
383  ASSERT(file);
384  ASSERT(dest);
385 
386  if (fseek(file, 0L, SEEK_SET)!=0)
387  SG_ERROR("Error seeking file '%s' to the beginning.\n", filename);
388 
389  char fourcc[4];
390  uint16_t endian=0;
391 
392  if (fread(&fourcc, sizeof(char), 4, file)!=4)
393  SG_ERROR("Error reading fourcc header in file '%s'\n", filename);
394 
395  if (fread(&endian, sizeof(uint16_t), 1, file)!=1)
396  SG_ERROR("Error reading endian header in file '%s'\n", filename);
397 
398  if ((fread(&dest->m_ctype, sizeof(dest->m_ctype), 1, file)!=1) ||
399  (fread(&dest->m_ptype, sizeof(dest->m_ptype), 1, file)!=1))
400  SG_ERROR("Error reading datatype header in file '%s'\n", filename);
401 
402  if (strncmp(fourcc, "SG01", 4))
403  SG_ERROR("Header mismatch, expected SG01 in file '%s'\n", filename);
404 }
405 
406 void
407 CBinaryFile::write_header(const TSGDataType* datatype)
408 {
409  ASSERT(file);
410 
411  const char* fourcc="SG01";
412  uint16_t endian=0x1234;
413 
414  if (!((fwrite(fourcc, sizeof(char), 4, file)==4) &&
415  (fwrite(&endian, sizeof(uint16_t), 1, file)==1) &&
416  (fwrite(&datatype->m_ctype, sizeof(datatype->m_ctype), 1,
417  file)==1)
418  && (fwrite(&datatype->m_ptype, sizeof(datatype->m_ptype), 1,
419  file)==1)
420  ))
421  SG_ERROR("Error writing header\n");
422 }
SHOGUN Machine Learning Toolbox - Documentation