IT++ Logo
binfile.cpp
Go to the documentation of this file.
00001 
00029 #include <itpp/base/binfile.h>
00030 #include <itpp/base/math/misc.h>
00031 #include <cstring>
00032 
00033 
00034 using std::ofstream;
00035 using std::ifstream;
00036 using std::fstream;
00037 using std::ios;
00038 
00039 
00040 namespace itpp
00041 {
00042 
00044 template<typename T1, typename T2> inline
00045 void read_endian(T1& st, T2& data, bool switch_endian = false)
00046 {
00047   int bytes = sizeof(T2);
00048   char *c = reinterpret_cast<char *>(&data);
00049   if (!switch_endian)
00050     st.read(c, bytes);
00051   else
00052     for (int i = bytes - 1; i >= 0; i--)
00053       st.get(c[i]);
00054 }
00055 
00057 template<typename T1, typename T2> inline
00058 void write_endian(T1& st, T2 data, bool switch_endian = false)
00059 {
00060   int bytes = sizeof(T2);
00061   char *c = reinterpret_cast<char *>(&data);
00062   if (!switch_endian)
00063     st.write(c, bytes);
00064   else
00065     for (int i = bytes - 1; i >= 0; i--)
00066       st.put(c[i]);
00067 }
00068 
00069 // ----------------------------------------------------------------------
00070 
00071 bool exist(const std::string& name)
00072 {
00073   bool file_exists = false;
00074   ifstream file(name.c_str(), ios::in);
00075   if (file.is_open()) {
00076     file_exists = true;
00077   }
00078   file.close();
00079   return file_exists;
00080 }
00081 
00082 // ----------------------------------------------------------------------
00083 // bfstream_base
00084 // ----------------------------------------------------------------------
00085 
00086 bfstream_base::bfstream_base(endian e):
00087     switch_endianity(false),
00088     native_endianity(is_bigendian() ? b_endian : l_endian)
00089 {
00090   if (native_endianity != e)
00091     switch_endianity = true;
00092 }
00093 
00094 // ----------------------------------------------------------------------
00095 // bofstream
00096 // ----------------------------------------------------------------------
00097 
00098 bofstream::bofstream(const std::string& name, endian e) :
00099     bfstream_base(e), ofstream(name.c_str(), ios::out | ios::binary) {}
00100 
00101 bofstream::bofstream() : bfstream_base(), ofstream() {}
00102 
00103 void bofstream::open(const std::string& name, endian e)
00104 {
00105   if (native_endianity != e)
00106     switch_endianity = true;
00107   else
00108     switch_endianity = false;
00109   ofstream::open(name.c_str(), ios::out | ios::binary);
00110 }
00111 
00112 bofstream& bofstream::operator<<(char a)
00113 {
00114   put(a);
00115   return *this;
00116 }
00117 
00118 bofstream& bofstream::operator<<(unsigned char a)
00119 {
00120   put(static_cast<char>(a));
00121   return *this;
00122 }
00123 
00124 bofstream& bofstream::operator<<(int16_t a)
00125 {
00126   write_endian<bofstream, int16_t>(*this, a, switch_endianity);
00127   return *this;
00128 }
00129 
00130 bofstream& bofstream::operator<<(uint16_t a)
00131 {
00132   write_endian<bofstream, uint16_t>(*this, a, switch_endianity);
00133   return *this;
00134 }
00135 
00136 bofstream& bofstream::operator<<(int32_t a)
00137 {
00138   write_endian<bofstream, int32_t>(*this, a, switch_endianity);
00139   return *this;
00140 }
00141 
00142 bofstream& bofstream::operator<<(uint32_t a)
00143 {
00144   write_endian<bofstream, uint32_t>(*this, a, switch_endianity);
00145   return *this;
00146 }
00147 
00148 bofstream& bofstream::operator<<(int64_t a)
00149 {
00150   write_endian<bofstream, int64_t>(*this, a, switch_endianity);
00151   return *this;
00152 }
00153 
00154 bofstream& bofstream::operator<<(uint64_t a)
00155 {
00156   write_endian<bofstream, uint64_t>(*this, a, switch_endianity);
00157   return *this;
00158 }
00159 
00160 bofstream& bofstream::operator<<(float a)
00161 {
00162   write_endian<bofstream, float>(*this, a, switch_endianity);
00163   return *this;
00164 }
00165 
00166 bofstream& bofstream::operator<<(double a)
00167 {
00168   write_endian<bofstream, double>(*this, a, switch_endianity);
00169   return *this;
00170 }
00171 
00172 bofstream& bofstream::operator<<(const char *a)
00173 {
00174   write(a, strlen(a) + 1);
00175   return *this;
00176 }
00177 
00178 bofstream& bofstream::operator<<(const std::string& a)
00179 {
00180   write(a.c_str(), a.size() + 1);
00181   return *this;
00182 }
00183 
00184 // ----------------------------------------------------------------------
00185 // bifstream
00186 // ----------------------------------------------------------------------
00187 
00188 bifstream::bifstream(const std::string& name, endian e) :
00189     bfstream_base(e), ifstream(name.c_str(), ios::in | ios::binary) {}
00190 
00191 bifstream::bifstream() : bfstream_base(), ifstream() {}
00192 
00193 void bifstream::open(const std::string& name, endian e)
00194 {
00195   if (native_endianity != e)
00196     switch_endianity = true;
00197   else
00198     switch_endianity = false;
00199   ifstream::open(name.c_str(), ios::in | ios::binary);
00200 }
00201 
00202 int bifstream::length() // in bytes
00203 {
00204   std::streampos pos1, len;
00205   pos1 = tellg();
00206   seekg(0, ios::end);
00207   len = tellg();
00208   seekg(pos1);
00209   return int(len);
00210 }
00211 
00212 bifstream& bifstream::operator>>(char& a)
00213 {
00214   get(a);
00215   return *this;
00216 }
00217 
00218 bifstream& bifstream::operator>>(unsigned char& a)
00219 {
00220   char tmp;
00221   get(tmp);
00222   a = tmp;
00223   return *this;
00224 }
00225 
00226 bifstream& bifstream::operator>>(int16_t& a)
00227 {
00228   read_endian<bifstream, int16_t>(*this, a, switch_endianity);
00229   return *this;
00230 }
00231 
00232 bifstream& bifstream::operator>>(uint16_t& a)
00233 {
00234   read_endian<bifstream, uint16_t>(*this, a, switch_endianity);
00235   return *this;
00236 }
00237 
00238 bifstream& bifstream::operator>>(int32_t& a)
00239 {
00240   read_endian<bifstream, int32_t>(*this, a, switch_endianity);
00241   return *this;
00242 }
00243 
00244 bifstream& bifstream::operator>>(uint32_t& a)
00245 {
00246   read_endian<bifstream, uint32_t>(*this, a, switch_endianity);
00247   return *this;
00248 }
00249 
00250 bifstream& bifstream::operator>>(int64_t& a)
00251 {
00252   read_endian<bifstream, int64_t>(*this, a, switch_endianity);
00253   return *this;
00254 }
00255 
00256 bifstream& bifstream::operator>>(uint64_t& a)
00257 {
00258   read_endian<bifstream, uint64_t>(*this, a, switch_endianity);
00259   return *this;
00260 }
00261 
00262 bifstream& bifstream::operator>>(float& a)
00263 {
00264   read_endian<bifstream, float>(*this, a, switch_endianity);
00265   return *this;
00266 }
00267 
00268 bifstream& bifstream::operator>>(double& a)
00269 {
00270   read_endian<bifstream, double>(*this, a, switch_endianity);
00271   return *this;
00272 }
00273 
00274 bifstream& bifstream::operator>>(char *a)
00275 {
00276   getline(a, '\0');
00277   return *this;
00278 }
00279 
00280 bifstream& bifstream::operator>>(std::string& a)
00281 {
00282   std::getline(*this, a, '\0');
00283   return *this;
00284 }
00285 
00286 // ----------------------------------------------------------------------
00287 // bfstream
00288 // ----------------------------------------------------------------------
00289 
00290 bfstream::bfstream(const std::string& name, endian e) :
00291     bfstream_base(e), fstream(name.c_str(), ios::in | ios::out | ios::binary)
00292 {}
00293 
00294 bfstream::bfstream() : bfstream_base(), fstream() {}
00295 
00296 void bfstream::open(const std::string& name, bool trnc, endian e)
00297 {
00298   if (native_endianity != e)
00299     switch_endianity = true;
00300   else
00301     switch_endianity = false;
00302 
00303   if (trnc)
00304     fstream::open(name.c_str(), ios::in | ios::out | ios::binary
00305                   | ios::trunc);
00306   else
00307     fstream::open(name.c_str(), ios::in | ios::out | ios::binary);
00308 }
00309 
00310 void bfstream::open_readonly(const std::string& name, endian e)
00311 {
00312   if (native_endianity != e)
00313     switch_endianity = true;
00314   else
00315     switch_endianity = false;
00316   fstream::open(name.c_str(), ios::in | ios::binary);
00317 }
00318 
00319 int bfstream::length() // in bytes
00320 {
00321   std::streampos pos1, len;
00322   pos1 = tellg();
00323   seekg(0, ios::end);
00324   len = tellg();
00325   seekg(pos1);
00326   return int(len);
00327 }
00328 
00329 bfstream& bfstream::operator<<(char a)
00330 {
00331   put(a);
00332   return *this;
00333 }
00334 
00335 bfstream& bfstream::operator<<(unsigned char a)
00336 {
00337   put(static_cast<char>(a));
00338   return *this;
00339 }
00340 
00341 bfstream& bfstream::operator<<(int16_t a)
00342 {
00343   write_endian<bfstream, int16_t>(*this, a, switch_endianity);
00344   return *this;
00345 }
00346 
00347 bfstream& bfstream::operator<<(uint16_t a)
00348 {
00349   write_endian<bfstream, uint16_t>(*this, a, switch_endianity);
00350   return *this;
00351 }
00352 
00353 bfstream& bfstream::operator<<(int32_t a)
00354 {
00355   write_endian<bfstream, int32_t>(*this, a, switch_endianity);
00356   return *this;
00357 }
00358 
00359 bfstream& bfstream::operator<<(uint32_t a)
00360 {
00361   write_endian<bfstream, uint32_t>(*this, a, switch_endianity);
00362   return *this;
00363 }
00364 
00365 bfstream& bfstream::operator<<(int64_t a)
00366 {
00367   write_endian<bfstream, int64_t>(*this, a, switch_endianity);
00368   return *this;
00369 }
00370 
00371 bfstream& bfstream::operator<<(uint64_t a)
00372 {
00373   write_endian<bfstream, uint64_t>(*this, a, switch_endianity);
00374   return *this;
00375 }
00376 
00377 bfstream& bfstream::operator<<(float a)
00378 {
00379   write_endian<bfstream, float>(*this, a, switch_endianity);
00380   return *this;
00381 }
00382 
00383 bfstream& bfstream::operator<<(double a)
00384 {
00385   write_endian<bfstream, double>(*this, a, switch_endianity);
00386   return *this;
00387 }
00388 
00389 bfstream& bfstream::operator<<(const char *a)
00390 {
00391   write(a, strlen(a) + 1);
00392   return *this;
00393 }
00394 
00395 bfstream& bfstream::operator<<(const std::string& a)
00396 {
00397   write(a.c_str(), a.size() + 1);
00398   return *this;
00399 }
00400 
00401 
00402 bfstream& bfstream::operator>>(char& a)
00403 {
00404   get(a);
00405   return *this;
00406 }
00407 
00408 bfstream& bfstream::operator>>(unsigned char& a)
00409 {
00410   char tmp;
00411   get(tmp);
00412   a = tmp;
00413   return *this;
00414 }
00415 
00416 bfstream& bfstream::operator>>(int16_t& a)
00417 {
00418   read_endian<bfstream, int16_t>(*this, a, switch_endianity);
00419   return *this;
00420 }
00421 
00422 bfstream& bfstream::operator>>(uint16_t& a)
00423 {
00424   read_endian<bfstream, uint16_t>(*this, a, switch_endianity);
00425   return *this;
00426 }
00427 
00428 bfstream& bfstream::operator>>(int32_t& a)
00429 {
00430   read_endian<bfstream, int32_t>(*this, a, switch_endianity);
00431   return *this;
00432 }
00433 
00434 bfstream& bfstream::operator>>(uint32_t& a)
00435 {
00436   read_endian<bfstream, uint32_t>(*this, a, switch_endianity);
00437   return *this;
00438 }
00439 
00440 bfstream& bfstream::operator>>(int64_t& a)
00441 {
00442   read_endian<bfstream, int64_t>(*this, a, switch_endianity);
00443   return *this;
00444 }
00445 
00446 bfstream& bfstream::operator>>(uint64_t& a)
00447 {
00448   read_endian<bfstream, uint64_t>(*this, a, switch_endianity);
00449   return *this;
00450 }
00451 
00452 bfstream& bfstream::operator>>(float& a)
00453 {
00454   read_endian<bfstream, float>(*this, a, switch_endianity);
00455   return *this;
00456 }
00457 
00458 bfstream& bfstream::operator>>(double& a)
00459 {
00460   read_endian<bfstream, double>(*this, a, switch_endianity);
00461   return *this;
00462 }
00463 
00464 bfstream& bfstream::operator>>(char *a)
00465 {
00466   getline(a, '\0');
00467   return *this;
00468 }
00469 
00470 bfstream& bfstream::operator>>(std::string& a)
00471 {
00472   std::getline(*this, a, '\0');
00473   return *this;
00474 }
00475 
00476 } // namespace itpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SourceForge Logo

Generated on Wed Jul 27 2011 16:27:04 for IT++ by Doxygen 1.7.4