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