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