00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include <shogun/io/File.h>
00012 #include <shogun/features/SparseFeatures.h>
00013 #include <shogun/io/BinaryFile.h>
00014
00015 using namespace shogun;
00016
00017 CBinaryFile::CBinaryFile()
00018 {
00019 SG_UNSTABLE("CBinaryFile::CBinaryFile()", "\n");
00020 }
00021
00022 CBinaryFile::CBinaryFile(FILE* f, const char* name) : CFile(f, name)
00023 {
00024 }
00025
00026 CBinaryFile::CBinaryFile(const char* fname, char rw, const char* name) : CFile(fname, rw, name)
00027 {
00028 }
00029
00030 CBinaryFile::~CBinaryFile()
00031 {
00032 }
00033
00034 #define GET_VECTOR(fname, sg_type, datatype) \
00035 void CBinaryFile::fname(sg_type*& vec, int32_t& len) \
00036 { \
00037 if (!file) \
00038 SG_ERROR("File invalid.\n"); \
00039 TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
00040 if (dtype!=datatype) \
00041 SG_ERROR("Datatype mismatch\n"); \
00042 \
00043 if (fread(&len, sizeof(int32_t), 1, file)!=1) \
00044 SG_ERROR("Failed to read vector length\n"); \
00045 vec=SG_MALLOC(sg_type, len); \
00046 if (fread(vec, sizeof(sg_type), len, file)!=(size_t) len) \
00047 SG_ERROR("Failed to read Matrix\n"); \
00048 }
00049
00050 GET_VECTOR(get_vector, int8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT8))
00051 GET_VECTOR(get_vector, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
00052 GET_VECTOR(get_vector, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
00053 GET_VECTOR(get_vector, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
00054 GET_VECTOR(get_vector, uint32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT32))
00055 GET_VECTOR(get_vector, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
00056 GET_VECTOR(get_vector, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
00057 GET_VECTOR(get_vector, floatmax_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOATMAX))
00058 GET_VECTOR(get_vector, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00059 GET_VECTOR(get_vector, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00060 GET_VECTOR(get_vector, int64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
00061 GET_VECTOR(get_vector, uint64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT64))
00062 #undef GET_VECTOR
00063
00064 #define GET_MATRIX(fname, sg_type, datatype) \
00065 void CBinaryFile::fname(sg_type*& matrix, int32_t& num_feat, int32_t& num_vec) \
00066 { \
00067 if (!file) \
00068 SG_ERROR("File invalid.\n"); \
00069 TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
00070 if (dtype!=datatype) \
00071 SG_ERROR("Datatype mismatch\n"); \
00072 \
00073 if (fread(&num_feat, sizeof(int32_t), 1, file)!=1 || \
00074 fread(&num_vec, sizeof(int32_t), 1, file)!=1) \
00075 SG_ERROR("Failed to read Matrix dimensions\n"); \
00076 matrix=SG_MALLOC(sg_type, int64_t(num_feat)*num_vec); \
00077 if (fread(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec) \
00078 SG_ERROR("Failed to read Matrix\n"); \
00079 }
00080
00081 GET_MATRIX(get_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
00082 GET_MATRIX(get_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
00083 GET_MATRIX(get_int8_matrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
00084 GET_MATRIX(get_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00085 GET_MATRIX(get_uint_matrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00086 GET_MATRIX(get_long_matrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00087 GET_MATRIX(get_ulong_matrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00088 GET_MATRIX(get_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00089 GET_MATRIX(get_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00090 GET_MATRIX(get_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
00091 GET_MATRIX(get_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
00092 GET_MATRIX(get_longreal_matrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
00093 #undef GET_MATRIX
00094
00095 #define GET_NDARRAY(fname,sg_type,datatype) \
00096 void CBinaryFile::fname(sg_type *& array, int32_t *& dims,int32_t & num_dims)\
00097 { \
00098 size_t total = 1; \
00099 \
00100 if (!file) \
00101 SG_ERROR("File invalid.\n"); \
00102 \
00103 TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); \
00104 read_header(&dtype); \
00105 \
00106 if (dtype!=datatype) \
00107 SG_ERROR("Datatype mismatch\n"); \
00108 \
00109 if (fread(&num_dims,sizeof(int32_t),1,file) != 1) \
00110 SG_ERROR("Failed to read number of dimensions"); \
00111 \
00112 dims = SG_MALLOC(int32_t, num_dims); \
00113 if (fread(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims) \
00114 SG_ERROR("Failed to read sizes of dimensions!"); \
00115 \
00116 for (int32_t i = 0;i < num_dims;i++) \
00117 total *= dims[i]; \
00118 \
00119 array = SG_MALLOC(sg_type, total); \
00120 if (fread(array,sizeof(sg_type),total,file) != (size_t)total) \
00121 SG_ERROR("Failed to read array data!"); \
00122 }
00123
00124 GET_NDARRAY(get_ndarray,uint8_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT8));
00125 GET_NDARRAY(get_ndarray,char,TSGDataType(CT_NDARRAY, ST_NONE, PT_CHAR));
00126 GET_NDARRAY(get_ndarray,int32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT32));
00127 GET_NDARRAY(get_ndarray,int16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT16));
00128 GET_NDARRAY(get_ndarray,uint16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT16));
00129 GET_NDARRAY(get_ndarray,float32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT32));
00130 GET_NDARRAY(get_ndarray,float64_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT64));
00131 #undef GET_NDARRAY
00132
00133 #define GET_SPARSEMATRIX(fname, sg_type, datatype) \
00134 void CBinaryFile::fname(SGSparseVector<sg_type>*& matrix, int32_t& num_feat, int32_t& num_vec) \
00135 { \
00136 if (!(file)) \
00137 SG_ERROR("File invalid.\n"); \
00138 \
00139 TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
00140 if (dtype!=datatype) \
00141 SG_ERROR("Datatype mismatch\n"); \
00142 \
00143 if (fread(&num_vec, sizeof(int32_t), 1, file)!=1) \
00144 SG_ERROR("Failed to read number of vectors\n"); \
00145 \
00146 matrix=SG_MALLOC(SGSparseVector<sg_type>, num_vec); \
00147 \
00148 for (int32_t i=0; i<num_vec; i++) \
00149 { \
00150 new (&matrix[i]) SGSparseVector<sg_type>(); \
00151 int32_t len=0; \
00152 if (fread(&len, sizeof(int32_t), 1, file)!=1) \
00153 SG_ERROR("Failed to read sparse vector length of vector idx=%d\n", i); \
00154 matrix[i].num_feat_entries=len; \
00155 SGSparseVectorEntry<sg_type>* vec = SG_MALLOC(SGSparseVectorEntry<sg_type>, len); \
00156 if (fread(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len) \
00157 SG_ERROR("Failed to read sparse vector %d\n", i); \
00158 matrix[i].features=vec; \
00159 } \
00160 }
00161 GET_SPARSEMATRIX(get_sparse_matrix, bool, TSGDataType(CT_MATRIX, ST_NONE, PT_BOOL))
00162 GET_SPARSEMATRIX(get_sparse_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
00163 GET_SPARSEMATRIX(get_sparse_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
00164 GET_SPARSEMATRIX(get_int8_sparsematrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
00165 GET_SPARSEMATRIX(get_sparse_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00166 GET_SPARSEMATRIX(get_uint_sparsematrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00167 GET_SPARSEMATRIX(get_long_sparsematrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00168 GET_SPARSEMATRIX(get_ulong_sparsematrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00169 GET_SPARSEMATRIX(get_sparse_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00170 GET_SPARSEMATRIX(get_sparse_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00171 GET_SPARSEMATRIX(get_sparse_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
00172 GET_SPARSEMATRIX(get_sparse_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
00173 GET_SPARSEMATRIX(get_longreal_sparsematrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
00174 #undef GET_SPARSEMATRIX
00175
00176
00177 #define GET_STRING_LIST(fname, sg_type, datatype) \
00178 void CBinaryFile::fname(SGString<sg_type>*& strings, int32_t& num_str, int32_t& max_string_len) \
00179 { \
00180 strings=NULL; \
00181 num_str=0; \
00182 max_string_len=0; \
00183 \
00184 if (!file) \
00185 SG_ERROR("File invalid.\n"); \
00186 \
00187 TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
00188 if (dtype!=datatype) \
00189 SG_ERROR("Datatype mismatch\n"); \
00190 \
00191 if (fread(&num_str, sizeof(int32_t), 1, file)!=1) \
00192 SG_ERROR("Failed to read number of strings\n"); \
00193 \
00194 strings=SG_MALLOC(SGString<sg_type>, num_str); \
00195 \
00196 for (int32_t i=0; i<num_str; i++) \
00197 { \
00198 int32_t len=0; \
00199 if (fread(&len, sizeof(int32_t), 1, file)!=1) \
00200 SG_ERROR("Failed to read string length of string with idx=%d\n", i); \
00201 strings[i].slen=len; \
00202 sg_type* str = SG_MALLOC(sg_type, len); \
00203 if (fread(str, sizeof(sg_type), len, file)!= (size_t) len) \
00204 SG_ERROR("Failed to read string %d\n", i); \
00205 strings[i].string=str; \
00206 } \
00207 }
00208
00209 GET_STRING_LIST(get_string_list, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
00210 GET_STRING_LIST(get_string_list, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
00211 GET_STRING_LIST(get_int8_string_list, int8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT8))
00212 GET_STRING_LIST(get_string_list, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
00213 GET_STRING_LIST(get_uint_string_list, uint32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
00214 GET_STRING_LIST(get_long_string_list, int64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
00215 GET_STRING_LIST(get_ulong_string_list, uint64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
00216 GET_STRING_LIST(get_string_list, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00217 GET_STRING_LIST(get_string_list, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00218 GET_STRING_LIST(get_string_list, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
00219 GET_STRING_LIST(get_string_list, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
00220 GET_STRING_LIST(get_longreal_string_list, floatmax_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOATMAX))
00221 #undef GET_STRING_LIST
00222
00225 #define SET_VECTOR(fname, sg_type, dtype) \
00226 void CBinaryFile::fname(const sg_type* vec, int32_t len) \
00227 { \
00228 if (!(file && vec)) \
00229 SG_ERROR("File or vector invalid.\n"); \
00230 \
00231 TSGDataType t dtype; write_header(&t); \
00232 \
00233 if (fwrite(&len, sizeof(int32_t), 1, file)!=1 || \
00234 fwrite(vec, sizeof(sg_type), len, file)!=(size_t) len) \
00235 SG_ERROR("Failed to write vector\n"); \
00236 }
00237 SET_VECTOR(set_vector, int8_t, (CT_VECTOR, ST_NONE, PT_INT8))
00238 SET_VECTOR(set_vector, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
00239 SET_VECTOR(set_vector, char, (CT_VECTOR, ST_NONE, PT_CHAR))
00240 SET_VECTOR(set_vector, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
00241 SET_VECTOR(set_vector, uint32_t, (CT_VECTOR, ST_NONE, PT_UINT32))
00242 SET_VECTOR(set_vector, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
00243 SET_VECTOR(set_vector, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
00244 SET_VECTOR(set_vector, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX))
00245 SET_VECTOR(set_vector, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00246 SET_VECTOR(set_vector, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00247 SET_VECTOR(set_vector, int64_t, (CT_VECTOR, ST_NONE, PT_INT64))
00248 SET_VECTOR(set_vector, uint64_t, (CT_VECTOR, ST_NONE, PT_UINT64))
00249 #undef SET_VECTOR
00250
00251 #define SET_MATRIX(fname, sg_type, dtype) \
00252 void CBinaryFile::fname(const sg_type* matrix, int32_t num_feat, int32_t num_vec) \
00253 { \
00254 if (!(file && matrix)) \
00255 SG_ERROR("File or matrix invalid.\n"); \
00256 \
00257 TSGDataType t dtype; write_header(&t); \
00258 \
00259 if (fwrite(&num_feat, sizeof(int32_t), 1, file)!=1 || \
00260 fwrite(&num_vec, sizeof(int32_t), 1, file)!=1 || \
00261 fwrite(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec) \
00262 SG_ERROR("Failed to write Matrix\n"); \
00263 }
00264 SET_MATRIX(set_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
00265 SET_MATRIX(set_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
00266 SET_MATRIX(set_int8_matrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
00267 SET_MATRIX(set_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00268 SET_MATRIX(set_uint_matrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00269 SET_MATRIX(set_long_matrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00270 SET_MATRIX(set_ulong_matrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00271 SET_MATRIX(set_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00272 SET_MATRIX(set_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00273 SET_MATRIX(set_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
00274 SET_MATRIX(set_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
00275 SET_MATRIX(set_longreal_matrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
00276 #undef SET_MATRIX
00277
00278 #define SET_NDARRAY(fname,sg_type,datatype) \
00279 void CBinaryFile::fname(const sg_type * array, int32_t * dims,int32_t num_dims) \
00280 { \
00281 size_t total = 1; \
00282 \
00283 if (!file) \
00284 SG_ERROR("File invalid.\n"); \
00285 \
00286 if (!array) \
00287 SG_ERROR("Invalid array!\n"); \
00288 \
00289 TSGDataType t datatype; \
00290 write_header(&t); \
00291 \
00292 if (fwrite(&num_dims,sizeof(int32_t),1,file) != 1) \
00293 SG_ERROR("Failed to write number of dimensions!\n"); \
00294 \
00295 if (fwrite(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims) \
00296 SG_ERROR("Failed to write sizes of dimensions!\n"); \
00297 \
00298 for (int32_t i = 0;i < num_dims;i++) \
00299 total *= dims[i]; \
00300 \
00301 if (fwrite(array,sizeof(sg_type),total,file) != (size_t)total) \
00302 SG_ERROR("Failed to write array data!\n"); \
00303 }
00304
00305 SET_NDARRAY(set_ndarray,uint8_t,(CT_NDARRAY, ST_NONE, PT_UINT8));
00306 SET_NDARRAY(set_ndarray,char,(CT_NDARRAY, ST_NONE, PT_CHAR));
00307 SET_NDARRAY(set_ndarray,int32_t,(CT_NDARRAY, ST_NONE, PT_INT32));
00308 SET_NDARRAY(set_ndarray,int16_t,(CT_NDARRAY, ST_NONE, PT_INT16));
00309 SET_NDARRAY(set_ndarray,uint16_t,(CT_NDARRAY, ST_NONE, PT_UINT16));
00310 SET_NDARRAY(set_ndarray,float32_t,(CT_NDARRAY, ST_NONE, PT_FLOAT32));
00311 SET_NDARRAY(set_ndarray,float64_t,(CT_NDARRAY, ST_NONE, PT_FLOAT64));
00312 #undef SET_NDARRAY
00313
00314 #define SET_SPARSEMATRIX(fname, sg_type, dtype) \
00315 void CBinaryFile::fname(const SGSparseVector<sg_type>* matrix, \
00316 int32_t num_feat, int32_t num_vec) \
00317 { \
00318 if (!(file && matrix)) \
00319 SG_ERROR("File or matrix invalid.\n"); \
00320 \
00321 TSGDataType t dtype; write_header(&t); \
00322 \
00323 if (fwrite(&num_vec, sizeof(int32_t), 1, file)!=1) \
00324 SG_ERROR("Failed to write Sparse Matrix\n"); \
00325 \
00326 for (int32_t i=0; i<num_vec; i++) \
00327 { \
00328 SGSparseVectorEntry<sg_type>* vec = matrix[i].features; \
00329 int32_t len=matrix[i].num_feat_entries; \
00330 if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \
00331 (fwrite(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len)) \
00332 SG_ERROR("Failed to write Sparse Matrix\n"); \
00333 } \
00334 }
00335 SET_SPARSEMATRIX(set_sparse_matrix, bool, (CT_MATRIX, ST_NONE, PT_BOOL))
00336 SET_SPARSEMATRIX(set_sparse_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
00337 SET_SPARSEMATRIX(set_sparse_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
00338 SET_SPARSEMATRIX(set_int8_sparsematrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
00339 SET_SPARSEMATRIX(set_sparse_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00340 SET_SPARSEMATRIX(set_uint_sparsematrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00341 SET_SPARSEMATRIX(set_long_sparsematrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00342 SET_SPARSEMATRIX(set_ulong_sparsematrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00343 SET_SPARSEMATRIX(set_sparse_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00344 SET_SPARSEMATRIX(set_sparse_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00345 SET_SPARSEMATRIX(set_sparse_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
00346 SET_SPARSEMATRIX(set_sparse_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
00347 SET_SPARSEMATRIX(set_longreal_sparsematrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
00348 #undef SET_SPARSEMATRIX
00349
00350 #define SET_STRING_LIST(fname, sg_type, dtype) \
00351 void CBinaryFile::fname(const SGString<sg_type>* strings, int32_t num_str) \
00352 { \
00353 if (!(file && strings)) \
00354 SG_ERROR("File or strings invalid.\n"); \
00355 \
00356 TSGDataType t dtype; write_header(&t); \
00357 for (int32_t i=0; i<num_str; i++) \
00358 { \
00359 int32_t len = strings[i].slen; \
00360 if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \
00361 (fwrite(strings[i].string, sizeof(sg_type), len, file)!= (size_t) len)) \
00362 SG_ERROR("Failed to write Sparse Matrix\n"); \
00363 } \
00364 }
00365 SET_STRING_LIST(set_string_list, char, (CT_VECTOR, ST_NONE, PT_CHAR))
00366 SET_STRING_LIST(set_string_list, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
00367 SET_STRING_LIST(set_int8_string_list, int8_t, (CT_VECTOR, ST_NONE, PT_INT8))
00368 SET_STRING_LIST(set_string_list, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
00369 SET_STRING_LIST(set_uint_string_list, uint32_t, (CT_VECTOR, ST_NONE, PT_INT32))
00370 SET_STRING_LIST(set_long_string_list, int64_t, (CT_VECTOR, ST_NONE, PT_INT64))
00371 SET_STRING_LIST(set_ulong_string_list, uint64_t, (CT_VECTOR, ST_NONE, PT_INT64))
00372 SET_STRING_LIST(set_string_list, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00373 SET_STRING_LIST(set_string_list, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00374 SET_STRING_LIST(set_string_list, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
00375 SET_STRING_LIST(set_string_list, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
00376 SET_STRING_LIST(set_longreal_string_list, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX))
00377 #undef SET_STRING_LIST
00378
00379
00380 int32_t CBinaryFile::parse_first_header(TSGDataType& type)
00381 {
00382 return -1;
00383 }
00384
00385 int32_t CBinaryFile::parse_next_header(TSGDataType& type)
00386 {
00387 return -1;
00388 }
00389
00390 void
00391 CBinaryFile::read_header(TSGDataType* dest)
00392 {
00393 ASSERT(file);
00394 ASSERT(dest);
00395
00396 if (fseek(file, 0L, SEEK_SET)!=0)
00397 SG_ERROR("Error seeking file '%s' to the beginning.\n", filename);
00398
00399 char fourcc[4];
00400 uint16_t endian=0;
00401
00402 if (fread(&fourcc, sizeof(char), 4, file)!=4)
00403 SG_ERROR("Error reading fourcc header in file '%s'\n", filename);
00404
00405 if (fread(&endian, sizeof(uint16_t), 1, file)!=1)
00406 SG_ERROR("Error reading endian header in file '%s'\n", filename);
00407
00408 if ((fread(&dest->m_ctype, sizeof(dest->m_ctype), 1, file)!=1) ||
00409 (fread(&dest->m_ptype, sizeof(dest->m_ptype), 1, file)!=1))
00410 SG_ERROR("Error reading datatype header in file '%s'\n", filename);
00411
00412 if (strncmp(fourcc, "SG01", 4))
00413 SG_ERROR("Header mismatch, expected SG01 in file '%s'\n", filename);
00414 }
00415
00416 void
00417 CBinaryFile::write_header(const TSGDataType* datatype)
00418 {
00419 ASSERT(file);
00420
00421 const char* fourcc="SG01";
00422 uint16_t endian=0x1234;
00423
00424 if (!((fwrite(fourcc, sizeof(char), 4, file)==4) &&
00425 (fwrite(&endian, sizeof(uint16_t), 1, file)==1) &&
00426 (fwrite(&datatype->m_ctype, sizeof(datatype->m_ctype), 1,
00427 file)==1)
00428 && (fwrite(&datatype->m_ptype, sizeof(datatype->m_ptype), 1,
00429 file)==1)
00430 ))
00431 SG_ERROR("Error writing header\n");
00432 }