SHOGUN
v3.2.0
|
00001 /* 00002 * This program is free software; you can redistribute it and/or modify 00003 * it under the terms of the GNU General Public License as published by 00004 * the Free Software Foundation; either version 3 of the License, or 00005 * (at your option) any later version. 00006 * 00007 * Written (W) 2010 Soeren Sonnenburg 00008 * Copyright (C) 2010 Berlin Institute of Technology 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_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_matrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32)) 00086 GET_MATRIX(get_matrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64)) 00087 GET_MATRIX(get_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_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 num_feat = CMath::max(num_feat, matrix[i].get_num_dimensions()); \ 00160 } \ 00161 } 00162 GET_SPARSEMATRIX(get_sparse_matrix, bool, TSGDataType(CT_MATRIX, ST_NONE, PT_BOOL)) 00163 GET_SPARSEMATRIX(get_sparse_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR)) 00164 GET_SPARSEMATRIX(get_sparse_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8)) 00165 GET_SPARSEMATRIX(get_sparse_matrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8)) 00166 GET_SPARSEMATRIX(get_sparse_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32)) 00167 GET_SPARSEMATRIX(get_sparse_matrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32)) 00168 GET_SPARSEMATRIX(get_sparse_matrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64)) 00169 GET_SPARSEMATRIX(get_sparse_matrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64)) 00170 GET_SPARSEMATRIX(get_sparse_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16)) 00171 GET_SPARSEMATRIX(get_sparse_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16)) 00172 GET_SPARSEMATRIX(get_sparse_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32)) 00173 GET_SPARSEMATRIX(get_sparse_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64)) 00174 GET_SPARSEMATRIX(get_sparse_matrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX)) 00175 #undef GET_SPARSEMATRIX 00176 00177 00178 #define GET_STRING_LIST(fname, sg_type, datatype) \ 00179 void CBinaryFile::fname(SGString<sg_type>*& strings, int32_t& num_str, int32_t& max_string_len) \ 00180 { \ 00181 strings=NULL; \ 00182 num_str=0; \ 00183 max_string_len=0; \ 00184 \ 00185 if (!file) \ 00186 SG_ERROR("File invalid.\n") \ 00187 \ 00188 TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \ 00189 if (dtype!=datatype) \ 00190 SG_ERROR("Datatype mismatch\n") \ 00191 \ 00192 if (fread(&num_str, sizeof(int32_t), 1, file)!=1) \ 00193 SG_ERROR("Failed to read number of strings\n") \ 00194 \ 00195 strings=SG_MALLOC(SGString<sg_type>, num_str); \ 00196 \ 00197 for (int32_t i=0; i<num_str; i++) \ 00198 { \ 00199 int32_t len=0; \ 00200 if (fread(&len, sizeof(int32_t), 1, file)!=1) \ 00201 SG_ERROR("Failed to read string length of string with idx=%d\n", i) \ 00202 strings[i].slen=len; \ 00203 sg_type* str = SG_MALLOC(sg_type, len); \ 00204 if (fread(str, sizeof(sg_type), len, file)!= (size_t) len) \ 00205 SG_ERROR("Failed to read string %d\n", i) \ 00206 strings[i].string=str; \ 00207 } \ 00208 } 00209 00210 GET_STRING_LIST(get_string_list, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR)) 00211 GET_STRING_LIST(get_string_list, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8)) 00212 GET_STRING_LIST(get_string_list, int8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT8)) 00213 GET_STRING_LIST(get_string_list, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32)) 00214 GET_STRING_LIST(get_string_list, uint32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32)) 00215 GET_STRING_LIST(get_string_list, int64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64)) 00216 GET_STRING_LIST(get_string_list, uint64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64)) 00217 GET_STRING_LIST(get_string_list, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16)) 00218 GET_STRING_LIST(get_string_list, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16)) 00219 GET_STRING_LIST(get_string_list, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32)) 00220 GET_STRING_LIST(get_string_list, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64)) 00221 GET_STRING_LIST(get_string_list, floatmax_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOATMAX)) 00222 #undef GET_STRING_LIST 00223 00226 #define SET_VECTOR(fname, sg_type, dtype) \ 00227 void CBinaryFile::fname(const sg_type* vec, int32_t len) \ 00228 { \ 00229 if (!(file && vec)) \ 00230 SG_ERROR("File or vector invalid.\n") \ 00231 \ 00232 TSGDataType t dtype; write_header(&t); \ 00233 \ 00234 if (fwrite(&len, sizeof(int32_t), 1, file)!=1 || \ 00235 fwrite(vec, sizeof(sg_type), len, file)!=(size_t) len) \ 00236 SG_ERROR("Failed to write vector\n") \ 00237 } 00238 SET_VECTOR(set_vector, int8_t, (CT_VECTOR, ST_NONE, PT_INT8)) 00239 SET_VECTOR(set_vector, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8)) 00240 SET_VECTOR(set_vector, char, (CT_VECTOR, ST_NONE, PT_CHAR)) 00241 SET_VECTOR(set_vector, int32_t, (CT_VECTOR, ST_NONE, PT_INT32)) 00242 SET_VECTOR(set_vector, uint32_t, (CT_VECTOR, ST_NONE, PT_UINT32)) 00243 SET_VECTOR(set_vector, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32)) 00244 SET_VECTOR(set_vector, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64)) 00245 SET_VECTOR(set_vector, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX)) 00246 SET_VECTOR(set_vector, int16_t, (CT_VECTOR, ST_NONE, PT_INT16)) 00247 SET_VECTOR(set_vector, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16)) 00248 SET_VECTOR(set_vector, int64_t, (CT_VECTOR, ST_NONE, PT_INT64)) 00249 SET_VECTOR(set_vector, uint64_t, (CT_VECTOR, ST_NONE, PT_UINT64)) 00250 #undef SET_VECTOR 00251 00252 #define SET_MATRIX(fname, sg_type, dtype) \ 00253 void CBinaryFile::fname(const sg_type* matrix, int32_t num_feat, int32_t num_vec) \ 00254 { \ 00255 if (!(file && matrix)) \ 00256 SG_ERROR("File or matrix invalid.\n") \ 00257 \ 00258 TSGDataType t dtype; write_header(&t); \ 00259 \ 00260 if (fwrite(&num_feat, sizeof(int32_t), 1, file)!=1 || \ 00261 fwrite(&num_vec, sizeof(int32_t), 1, file)!=1 || \ 00262 fwrite(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec) \ 00263 SG_ERROR("Failed to write Matrix\n") \ 00264 } 00265 SET_MATRIX(set_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR)) 00266 SET_MATRIX(set_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8)) 00267 SET_MATRIX(set_matrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8)) 00268 SET_MATRIX(set_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32)) 00269 SET_MATRIX(set_matrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32)) 00270 SET_MATRIX(set_matrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64)) 00271 SET_MATRIX(set_matrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64)) 00272 SET_MATRIX(set_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16)) 00273 SET_MATRIX(set_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16)) 00274 SET_MATRIX(set_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32)) 00275 SET_MATRIX(set_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64)) 00276 SET_MATRIX(set_matrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX)) 00277 #undef SET_MATRIX 00278 00279 #define SET_NDARRAY(fname,sg_type,datatype) \ 00280 void CBinaryFile::fname(const sg_type * array, int32_t * dims,int32_t num_dims) \ 00281 { \ 00282 size_t total = 1; \ 00283 \ 00284 if (!file) \ 00285 SG_ERROR("File invalid.\n") \ 00286 \ 00287 if (!array) \ 00288 SG_ERROR("Invalid array!\n") \ 00289 \ 00290 TSGDataType t datatype; \ 00291 write_header(&t); \ 00292 \ 00293 if (fwrite(&num_dims,sizeof(int32_t),1,file) != 1) \ 00294 SG_ERROR("Failed to write number of dimensions!\n") \ 00295 \ 00296 if (fwrite(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims) \ 00297 SG_ERROR("Failed to write sizes of dimensions!\n") \ 00298 \ 00299 for (int32_t i = 0;i < num_dims;i++) \ 00300 total *= dims[i]; \ 00301 \ 00302 if (fwrite(array,sizeof(sg_type),total,file) != (size_t)total) \ 00303 SG_ERROR("Failed to write array data!\n") \ 00304 } 00305 00306 SET_NDARRAY(set_ndarray,uint8_t,(CT_NDARRAY, ST_NONE, PT_UINT8)); 00307 SET_NDARRAY(set_ndarray,char,(CT_NDARRAY, ST_NONE, PT_CHAR)); 00308 SET_NDARRAY(set_ndarray,int32_t,(CT_NDARRAY, ST_NONE, PT_INT32)); 00309 SET_NDARRAY(set_ndarray,int16_t,(CT_NDARRAY, ST_NONE, PT_INT16)); 00310 SET_NDARRAY(set_ndarray,uint16_t,(CT_NDARRAY, ST_NONE, PT_UINT16)); 00311 SET_NDARRAY(set_ndarray,float32_t,(CT_NDARRAY, ST_NONE, PT_FLOAT32)); 00312 SET_NDARRAY(set_ndarray,float64_t,(CT_NDARRAY, ST_NONE, PT_FLOAT64)); 00313 #undef SET_NDARRAY 00314 00315 #define SET_SPARSEMATRIX(fname, sg_type, dtype) \ 00316 void CBinaryFile::fname(const SGSparseVector<sg_type>* matrix, \ 00317 int32_t num_feat, int32_t num_vec) \ 00318 { \ 00319 if (!(file && matrix)) \ 00320 SG_ERROR("File or matrix invalid.\n") \ 00321 \ 00322 TSGDataType t dtype; write_header(&t); \ 00323 \ 00324 if (fwrite(&num_vec, sizeof(int32_t), 1, file)!=1) \ 00325 SG_ERROR("Failed to write Sparse Matrix\n") \ 00326 \ 00327 for (int32_t i=0; i<num_vec; i++) \ 00328 { \ 00329 SGSparseVectorEntry<sg_type>* vec = matrix[i].features; \ 00330 int32_t len=matrix[i].num_feat_entries; \ 00331 if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \ 00332 (fwrite(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len)) \ 00333 SG_ERROR("Failed to write Sparse Matrix\n") \ 00334 } \ 00335 } 00336 SET_SPARSEMATRIX(set_sparse_matrix, bool, (CT_MATRIX, ST_NONE, PT_BOOL)) 00337 SET_SPARSEMATRIX(set_sparse_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR)) 00338 SET_SPARSEMATRIX(set_sparse_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8)) 00339 SET_SPARSEMATRIX(set_sparse_matrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8)) 00340 SET_SPARSEMATRIX(set_sparse_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32)) 00341 SET_SPARSEMATRIX(set_sparse_matrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32)) 00342 SET_SPARSEMATRIX(set_sparse_matrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64)) 00343 SET_SPARSEMATRIX(set_sparse_matrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64)) 00344 SET_SPARSEMATRIX(set_sparse_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16)) 00345 SET_SPARSEMATRIX(set_sparse_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16)) 00346 SET_SPARSEMATRIX(set_sparse_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32)) 00347 SET_SPARSEMATRIX(set_sparse_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64)) 00348 SET_SPARSEMATRIX(set_sparse_matrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX)) 00349 #undef SET_SPARSEMATRIX 00350 00351 #define SET_STRING_LIST(fname, sg_type, dtype) \ 00352 void CBinaryFile::fname(const SGString<sg_type>* strings, int32_t num_str) \ 00353 { \ 00354 if (!(file && strings)) \ 00355 SG_ERROR("File or strings invalid.\n") \ 00356 \ 00357 TSGDataType t dtype; write_header(&t); \ 00358 for (int32_t i=0; i<num_str; i++) \ 00359 { \ 00360 int32_t len = strings[i].slen; \ 00361 if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \ 00362 (fwrite(strings[i].string, sizeof(sg_type), len, file)!= (size_t) len)) \ 00363 SG_ERROR("Failed to write Sparse Matrix\n") \ 00364 } \ 00365 } 00366 SET_STRING_LIST(set_string_list, char, (CT_VECTOR, ST_NONE, PT_CHAR)) 00367 SET_STRING_LIST(set_string_list, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8)) 00368 SET_STRING_LIST(set_string_list, int8_t, (CT_VECTOR, ST_NONE, PT_INT8)) 00369 SET_STRING_LIST(set_string_list, int32_t, (CT_VECTOR, ST_NONE, PT_INT32)) 00370 SET_STRING_LIST(set_string_list, uint32_t, (CT_VECTOR, ST_NONE, PT_INT32)) 00371 SET_STRING_LIST(set_string_list, int64_t, (CT_VECTOR, ST_NONE, PT_INT64)) 00372 SET_STRING_LIST(set_string_list, uint64_t, (CT_VECTOR, ST_NONE, PT_INT64)) 00373 SET_STRING_LIST(set_string_list, int16_t, (CT_VECTOR, ST_NONE, PT_INT16)) 00374 SET_STRING_LIST(set_string_list, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16)) 00375 SET_STRING_LIST(set_string_list, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32)) 00376 SET_STRING_LIST(set_string_list, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64)) 00377 SET_STRING_LIST(set_string_list, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX)) 00378 #undef SET_STRING_LIST 00379 00380 00381 int32_t CBinaryFile::parse_first_header(TSGDataType& type) 00382 { 00383 return -1; 00384 } 00385 00386 int32_t CBinaryFile::parse_next_header(TSGDataType& type) 00387 { 00388 return -1; 00389 } 00390 00391 void 00392 CBinaryFile::read_header(TSGDataType* dest) 00393 { 00394 ASSERT(file) 00395 ASSERT(dest) 00396 00397 if (fseek(file, 0L, SEEK_SET)!=0) 00398 SG_ERROR("Error seeking file '%s' to the beginning.\n", filename) 00399 00400 char fourcc[4]; 00401 uint16_t endian=0; 00402 00403 if (fread(&fourcc, sizeof(char), 4, file)!=4) 00404 SG_ERROR("Error reading fourcc header in file '%s'\n", filename) 00405 00406 if (fread(&endian, sizeof(uint16_t), 1, file)!=1) 00407 SG_ERROR("Error reading endian header in file '%s'\n", filename) 00408 00409 if ((fread(&dest->m_ctype, sizeof(dest->m_ctype), 1, file)!=1) || 00410 (fread(&dest->m_ptype, sizeof(dest->m_ptype), 1, file)!=1)) 00411 SG_ERROR("Error reading datatype header in file '%s'\n", filename) 00412 00413 if (strncmp(fourcc, "SG01", 4)) 00414 SG_ERROR("Header mismatch, expected SG01 in file '%s'\n", filename) 00415 } 00416 00417 void 00418 CBinaryFile::write_header(const TSGDataType* datatype) 00419 { 00420 ASSERT(file) 00421 00422 const char* fourcc="SG01"; 00423 uint16_t endian=0x1234; 00424 00425 if (!((fwrite(fourcc, sizeof(char), 4, file)==4) && 00426 (fwrite(&endian, sizeof(uint16_t), 1, file)==1) && 00427 (fwrite(&datatype->m_ctype, sizeof(datatype->m_ctype), 1, 00428 file)==1) 00429 && (fwrite(&datatype->m_ptype, sizeof(datatype->m_ptype), 1, 00430 file)==1) 00431 )) 00432 SG_ERROR("Error writing header\n") 00433 }