IT++ Logo Newcom Logo

itfile.cpp

Go to the documentation of this file.
00001 
00034 #include <itpp/base/itfile.h>
00035 
00036 
00037 namespace itpp {
00038 
00039   char it_file_base::file_magic[4] = { 'I', 'T', '+', '+' };
00040   char it_file_base::file_version = 2;
00041 
00042   it_ifile::it_ifile()
00043   {
00044   }
00045 
00046   it_ifile::it_ifile(const std::string &name)
00047   {
00048     open(name);
00049   }
00050 
00051   void it_ifile::open(const std::string &name)
00052   {
00053     if (!exist(name))
00054       it_error("File does not exist");
00055 
00056     s.open_readonly(name);
00057 
00058     if (!read_check_file_header()) {
00059       s.close();
00060      it_error("Corrupt file (Not an it-file)");
00061     }
00062 
00063   }
00064 
00065   void it_ifile::close()
00066   {
00067     s.close();
00068   }
00069 
00070   bool it_ifile::seek(const std::string &name)
00071   {
00072     data_header h;
00073     std::streampos p;
00074 
00075     s.clear();
00076     s.seekg(sizeof(file_header));
00077 
00078     while (true) {
00079       p = s.tellg();
00080       read_data_header(h);
00081       if (s.eof()) {
00082         s.clear();
00083         return false;
00084       }
00085       if (h.type != "" && h.name == name) {
00086         s.seekg(p);
00087         break;
00088       }
00089       s.seekg(p + static_cast<std::streampos>(h.block_bytes));
00090     }
00091 
00092     return true;
00093   }
00094 
00095   bool it_ifile::seek(int n)
00096   {
00097     data_header h;
00098     std::streampos p;
00099 
00100     s.clear();
00101     s.seekg(sizeof(file_header));
00102     for (int i=0; i<=n; i++) {
00103       p = s.tellg(); // changed from tellp() since probably an error
00104       read_data_header(h);
00105       if (s.eof()) {
00106         s.clear();
00107         return false;
00108       }
00109       if (h.type == "")
00110         i--;
00111       s.seekg(i==n ? p : p+static_cast<std::streampos>(h.block_bytes));
00112     }
00113     return true;
00114   }
00115 
00116   void it_ifile::info(std::string &name, std::string &type, int &bytes)
00117   {
00118     data_header h;
00119     std::streampos p;
00120 
00121     p = s.tellg(); // changed from tellp()
00122     read_data_header(h);
00123     s.seekg(p);
00124     name = h.name;
00125     type = h.type;
00126     bytes = h.data_bytes;
00127   }
00128 
00129   bool it_ifile::read_check_file_header()
00130   {
00131     file_header h;
00132 
00133     memset(&h, 0, sizeof(h)); // Clear the struct
00134     s.read(reinterpret_cast<char *>(&h), sizeof(h));
00135 
00136     return (memcmp(h.magic, file_magic, 4) == 0 && (h.version <= file_version) );
00137   }
00138 
00139   void it_ifile::read_data_header(data_header &h)
00140   {
00141     std::streampos p=s.tellg();
00142 
00143     s.clear();
00144     s >> h.endianity;
00145 
00146     if (s.eof())
00147       return;
00148     s.set_endianity(static_cast<bfstream_base::endian>(h.endianity));
00149     s >> h.hdr_bytes;
00150     s >> h.data_bytes;
00151     s >> h.block_bytes;
00152     s >> h.name;
00153     s >> h.type;
00154     s.seekg(p + static_cast<std::streampos>(h.hdr_bytes));
00155   }
00156 
00157   void it_ifile::low_level_read(bin &x)
00158   {
00159     s >> x;
00160   }
00161 
00162   void it_ifile::low_level_read(short &x)
00163   {
00164     s >> x;
00165   }
00166 
00167   void it_ifile::low_level_read(int &x)
00168   {
00169     s >> x;
00170   }
00171 
00172   /*
00173     void it_ifile::low_level_read(long_long &x)
00174     {
00175     s >> x;
00176     }
00177   */
00178 
00179   void it_ifile::low_level_read(float &x)
00180   {
00181     s >> x;
00182   }
00183 
00184   void it_ifile::low_level_read(double &x)
00185   {
00186     s >> x;
00187   }
00188 
00189   void it_ifile::low_level_read(std::complex<float> &x)
00190   {
00191     float x_real, x_imag;
00192     s >> x_real;
00193     s >> x_imag;
00194     x = std::complex<float>(x_real, x_imag);
00195   }
00196 
00197   void it_ifile::low_level_read(std::complex<double> &x)
00198   {
00199     double x_real, x_imag;
00200     s >> x_real;
00201     s >> x_imag;
00202     x = std::complex<double>(x_real, x_imag);
00203   }
00204 
00205   void it_ifile::low_level_read_lo(vec &v)
00206   {
00207     int i;
00208     float val;
00209 
00210     s >> i;
00211     v.set_size(i, false);
00212     for (i=0; i<v.size(); i++) {
00213       s >> val;
00214       v(i) = static_cast<double>(val);
00215     }
00216   }
00217 
00218   void it_ifile::low_level_read_hi(vec &v)
00219   {
00220     int i;
00221     double val;
00222 
00223     s >> i;
00224     v.set_size(i, false);
00225     for (i=0; i<v.size(); i++) {
00226       s >> val;
00227       v(i) = static_cast<double>(val);
00228     }
00229   }
00230 
00231   void it_ifile::low_level_read(ivec &v)
00232   {
00233     int i;
00234 
00235     s >> i;
00236     v.set_size(i, false);
00237     for (i=0; i<v.size(); i++)
00238       s >> v(i);
00239   }
00240 
00241   void it_ifile::low_level_read(bvec &v)
00242   {
00243     int i;
00244 
00245     s >> i;
00246     v.set_size(i, false);
00247     for (i=0; i<v.size(); i++)
00248       s >> v(i);
00249   }
00250 
00251   void it_ifile::low_level_read_lo(cvec &v)
00252   {
00253     int i;
00254     float val_real, val_imag;
00255 
00256     s >> i;
00257     v.set_size(i, false);
00258     for (i=0; i<v.size(); i++) {
00259       s >> val_real;
00260       s >> val_imag;
00261       v(i) = std::complex<double>(val_real, val_imag);
00262     }
00263   }
00264 
00265   void it_ifile::low_level_read_hi(cvec &v)
00266   {
00267     int i;
00268     double val_real, val_imag;
00269 
00270     s >> i;
00271     v.set_size(i, false);
00272     for (i=0; i<v.size(); i++) {
00273       s >> val_real;
00274       s >> val_imag;
00275       v(i) = std::complex<double>(val_real, val_imag);
00276     }
00277   }
00278 
00279   void it_ifile::low_level_read(std::string &str)
00280   {
00281     int i, j;
00282     char val;
00283     str = "";
00284 
00285     s >> i;
00286 
00287     for (j=0; j<i; j++) {
00288       s >> val;
00289       str += val;
00290     }
00291   }
00292 
00293   void it_ifile::low_level_read_lo(mat &m)
00294   {
00295     int i, j;
00296     float val;
00297 
00298     s >> i >> j;
00299     m.set_size(i, j, false);
00300     for (j=0; j<m.cols(); j++)
00301       for (i=0; i<m.rows(); i++) {
00302         s >> val;
00303         m(i,j) = static_cast<double>(val);
00304       }
00305   }
00306 
00307   void it_ifile::low_level_read_hi(mat &m)
00308   {
00309     int i, j;
00310     double val;
00311 
00312     s >> i >> j;
00313     m.set_size(i, j, false);
00314     for (j=0; j<m.cols(); j++)
00315       for (i=0; i<m.rows(); i++) {
00316         s >> val;
00317         m(i,j) = static_cast<double>(val);
00318       }
00319   }
00320 
00321   void it_ifile::low_level_read(imat &m)
00322   {
00323     int i, j;
00324 
00325     s >> i >> j;
00326     m.set_size(i, j, false);
00327     for (j=0; j<m.cols(); j++)
00328       for (i=0; i<m.rows(); i++)
00329         s >> m(i,j);
00330   }
00331 
00332   void it_ifile::low_level_read(bmat &m)
00333   {
00334     int i, j;
00335 
00336     s >> i >> j;
00337     m.set_size(i, j, false);
00338     for (j=0; j<m.cols(); j++)
00339       for (i=0; i<m.rows(); i++)
00340         s >> m(i,j);
00341   }
00342 
00343   void it_ifile::low_level_read_lo(cmat &m)
00344   {
00345     int i, j;
00346     float val_real, val_imag;
00347 
00348     s >> i >> j;
00349     m.set_size(i, j, false);
00350     for (j=0; j<m.cols(); j++)
00351       for (i=0; i<m.rows(); i++) {
00352         s >> val_real;
00353         s >> val_imag;
00354         m(i,j) = std::complex<double>(val_real, val_imag);
00355       }
00356   }
00357 
00358   void it_ifile::low_level_read_hi(cmat &m)
00359   {
00360     int i, j;
00361     double val_real, val_imag;
00362 
00363     s >> i >> j;
00364     m.set_size(i, j, false);
00365     for (j=0; j<m.cols(); j++)
00366       for (i=0; i<m.rows(); i++) {
00367         s >> val_real;
00368         s >> val_imag;
00369         m(i,j) = std::complex<double>(val_real, val_imag);
00370       }
00371   }
00372 
00373 
00374   void it_ifile::low_level_read_lo(Array<float> &v)
00375   {
00376     int i;
00377     float val;
00378 
00379     s >> i;
00380     v.set_size(i, false);
00381     for (i=0; i<v.size(); i++) {
00382       s >> val;
00383       v(i) = val;
00384     }
00385   }
00386 
00387   void it_ifile::low_level_read_lo(Array<double> &v)
00388   {
00389     int i;
00390     float val;
00391 
00392     s >> i;
00393     v.set_size(i, false);
00394     for (i=0; i<v.size(); i++) {
00395       s >> val;
00396       v(i) = static_cast<double>(val);
00397     }
00398   }
00399 
00400   void it_ifile::low_level_read_hi(Array<double> &v)
00401   {
00402     int i;
00403     double val;
00404 
00405     s >> i;
00406     v.set_size(i, false);
00407     for (i=0; i<v.size(); i++) {
00408       s >> val;
00409       v(i) = static_cast<double>(val);
00410     }
00411   }
00412 
00413   void it_ifile::low_level_read(Array<int> &v)
00414   {
00415     int i;
00416 
00417     s >> i;
00418     v.set_size(i, false);
00419     for (i=0; i<v.size(); i++)
00420       s >> v(i);
00421   }
00422 
00423   void it_ifile::low_level_read(Array<bin> &v)
00424   {
00425     int i;
00426 
00427     s >> i;
00428     v.set_size(i, false);
00429     for (i=0; i<v.size(); i++)
00430       s >> v(i);
00431   }
00432 
00433   void it_ifile::low_level_read_lo(Array<std::complex<float> > &v)
00434   {
00435     int i;
00436     float val_real, val_imag;
00437 
00438     s >> i;
00439     v.set_size(i, false);
00440     for (i=0; i<v.size(); i++) {
00441       s >> val_real;
00442       s >> val_imag;
00443       v(i) = std::complex<float>(val_real, val_imag);
00444     }
00445   }
00446 
00447   void it_ifile::low_level_read_lo(Array<std::complex<double> > &v)
00448   {
00449     int i;
00450     float val_real, val_imag;
00451 
00452     s >> i;
00453     v.set_size(i, false);
00454     for (i=0; i<v.size(); i++) {
00455       s >> val_real;
00456       s >> val_imag;
00457       v(i) = std::complex<double>(val_real, val_imag);
00458     }
00459   }
00460 
00461   void it_ifile::low_level_read_hi(Array<std::complex<double> > &v)
00462   {
00463     int i;
00464     double val_real, val_imag;
00465 
00466     s >> i;
00467     v.set_size(i, false);
00468     for (i=0; i<v.size(); i++) {
00469       s >> val_real;
00470       s >> val_imag;
00471       v(i) = std::complex<double>(val_real, val_imag);
00472     }
00473   }
00474 
00475   it_file::it_file()
00476   {
00477     low_prec = false;
00478     next_name = "";
00479   }
00480 
00481   it_file::it_file(const std::string &name, bool trunc)
00482   {
00483     low_prec = false;
00484     next_name = "";
00485     open(name, trunc);
00486   }
00487 
00488   void it_file::open(const std::string &name, bool trunc)
00489   {
00490     if (!exist(name))
00491       trunc = true;
00492 
00493     s.open(name, trunc);
00494     it_error_if(!s.is_open(), "Could not open file for writing");
00495 
00496     if (trunc)
00497       write_file_header();
00498     else if (!read_check_file_header()) {
00499       s.close();
00500       it_error("Corrupt file (Not an it-file)");
00501     }
00502   }
00503 
00504   void it_file::close()
00505   {
00506     s.close();
00507   }
00508 
00509   void it_file::flush()
00510   {
00511     s.flush();
00512   }
00513 
00514   void it_file::write_file_header()
00515   {
00516     s.write(file_magic, 4);
00517     s << file_version;
00518   }
00519 
00520   void it_file::write_data_header(const std::string &type, it_u32 size)
00521   {
00522     if (next_name == "")
00523       it_error("Try to write without a name");
00524     write_data_header(type, next_name, size);
00525     next_name = "";
00526   }
00527 
00528   void it_file::write_data_header(const std::string &type, const std::string &name, it_u32 size)
00529   {
00530     data_header h1, h2;
00531     std::streampos p;
00532     int availpos=0;
00533     bool removed=false;
00534     int skip;
00535 
00536     h1.endianity = s.get_native_endianity();
00537     h1.hdr_bytes = 1 + 3*4 + type.size()+1 + name.size()+1;
00538     h1.data_bytes = size;
00539     h1.block_bytes = h1.hdr_bytes + h1.data_bytes;
00540     h1.name = name;
00541     h1.type = type;
00542 
00543     if (exists(name))
00544       remove();
00545 
00546     // Try to find an empty space
00547     s.clear();
00548     s.seekg(sizeof(file_header));
00549     while (true) {
00550       p = s.tellp();
00551       read_data_header(h2);
00552       if (s.eof()) {
00553         s.clear();
00554         break;
00555       }
00556       skip = h2.block_bytes;
00557       if (h2.type != "" && h2.name == name) {
00558         s.seekg(p);
00559         remove();
00560         s.seekg(p);
00561         read_data_header(h2);
00562         removed = true;
00563         if (availpos != 0)
00564           break;
00565       }
00566       if (availpos == 0) {
00567         if (h2.type == "" && h2.block_bytes >= h1.block_bytes) {
00568           h1.block_bytes = h2.block_bytes;
00569           availpos = p;
00570         }
00571         else if (h2.block_bytes-h2.hdr_bytes-h2.data_bytes >= h1.block_bytes) {
00572           h1.block_bytes = h2.block_bytes - h2.hdr_bytes - h2.data_bytes;
00573           h2.block_bytes = h2.hdr_bytes + h2.data_bytes;
00574           s.seekp(p);
00575           write_data_header_here(h2);
00576           availpos = static_cast<int>(p) + h2.block_bytes;
00577           if (removed)
00578             break;
00579         }
00580       }
00581       s.seekg(p + static_cast<std::streampos>(skip));
00582     }
00583     if (availpos != 0)
00584       s.seekp(availpos);
00585     else
00586       s.seekp(0, std::ios::end);
00587 
00588     write_data_header_here(h1);
00589   }
00590 
00591   void it_file::write_data_header_here(const data_header &h)
00592   {
00593     s.set_endianity(static_cast<bfstream_base::endian>(h.endianity));
00594     s << h.endianity << h.hdr_bytes << h.data_bytes << h.block_bytes << h.name << h.type;
00595   }
00596 
00597   void it_file::remove(const std::string &name)
00598   {
00599     seek(name);
00600     remove();
00601   }
00602 
00603   void it_file::remove()
00604   {
00605     data_header h;
00606     std::streampos p;
00607 
00608     p = s.tellp();
00609     read_data_header(h);
00610     h.type = "";
00611     h.name = "";
00612     h.hdr_bytes = 1 + 3*4 + 1 + 1;
00613     h.data_bytes = 0;
00614     s.seekp(p);
00615     write_data_header_here(h);
00616     s.seekp(p + static_cast<std::streampos>(h.block_bytes));
00617   }
00618 
00619   bool it_file::exists(const std::string &name)
00620   {
00621     if (seek(name))
00622       return true;
00623     else
00624       return false;
00625   }
00626 
00627   void it_file::pack()
00628   {
00629     it_warning("pack() is not implemented!");
00630   }
00631 
00632   void it_file::low_level_write(bin x)
00633   {
00634     s << x;
00635   }
00636 
00637   void it_file::low_level_write(short x)
00638   {
00639     s << x;
00640   }
00641 
00642   void it_file::low_level_write(int x)
00643   {
00644     s << x;
00645   }
00646 
00647   void it_file::low_level_write(float x)
00648   {
00649     s << x;
00650   }
00651 
00652   void it_file::low_level_write(double x)
00653   {
00654     s << x;
00655   }
00656 
00657   void it_file::low_level_write(const std::complex<float> &x)
00658   {
00659     s << x.real();
00660     s << x.imag();
00661   }
00662 
00663   void it_file::low_level_write(const std::complex<double> &x)
00664   {
00665     s << x.real();
00666     s << x.imag();
00667   }
00668 
00669   void it_file::low_level_write(const vec &v)
00670   {
00671     if (get_low_precision()) {
00672       s << v.size();
00673       for (int i=0; i<v.size(); i++)
00674         s << static_cast<float>(v(i));
00675     }
00676     else {
00677       s << v.size();
00678       for (int i=0; i<v.size(); i++)
00679         s << static_cast<double>(v(i));
00680     }
00681   }
00682 
00683   void it_file::low_level_write(const ivec &v)
00684   {
00685     s << v.size();
00686     for (int i=0; i<v.size(); i++)
00687       s << v(i);
00688   }
00689 
00690   void it_file::low_level_write(const bvec &v)
00691   {
00692     s << v.size();
00693     for (int i=0; i<v.size(); i++)
00694       s << v(i);
00695   }
00696 
00697   void it_file::low_level_write(const cvec &v)
00698   {
00699     if (get_low_precision()) {
00700       s << v.size();
00701       for (int i=0; i<v.size(); i++) {
00702         s << static_cast<float>(v(i).real());
00703         s << static_cast<float>(v(i).imag());
00704       }
00705     }
00706     else {
00707       s << v.size();
00708       for (int i=0; i<v.size(); i++) {
00709         s << static_cast<double>(v(i).real());
00710         s << static_cast<double>(v(i).imag());
00711       }
00712     }
00713   }
00714 
00715   void it_file::low_level_write(const std::string &str)
00716   {
00717     int size = str.size();
00718     s << size;
00719 
00720     for (int i=0; i< size; i++)
00721       s << str[i];
00722   }
00723 
00724   void it_file::low_level_write(const mat &m)
00725   {
00726     int i, j;
00727 
00728     if (get_low_precision()) {
00729       s << m.rows() << m.cols();
00730       for (j=0; j<m.cols(); j++)
00731         for (i=0; i<m.rows(); i++)
00732           s << static_cast<float>(m(i,j));
00733     }
00734     else {
00735       s << m.rows() << m.cols();
00736       for (j=0; j<m.cols(); j++)
00737         for (i=0; i<m.rows(); i++)
00738           s << static_cast<double>(m(i,j));
00739     }
00740   }
00741 
00742   void it_file::low_level_write(const imat &m)
00743   {
00744     int i, j;
00745 
00746     s << m.rows() << m.cols();
00747     for (j=0; j<m.cols(); j++)
00748       for (i=0; i<m.rows(); i++)
00749         s << m(i,j);
00750   }
00751 
00752   void it_file::low_level_write(const bmat &m)
00753   {
00754     int i, j;
00755 
00756     s << m.rows() << m.cols();
00757     for (j=0; j<m.cols(); j++)
00758       for (i=0; i<m.rows(); i++)
00759         s << m(i,j);
00760   }
00761 
00762   void it_file::low_level_write(const cmat &m)
00763   {
00764     int i, j;
00765 
00766     if (get_low_precision()) {
00767       s << m.rows() << m.cols();
00768       for (j=0; j<m.cols(); j++)
00769         for (i=0; i<m.rows(); i++) {
00770           s << static_cast<float>(m(i,j).real());
00771           s << static_cast<float>(m(i,j).imag());
00772         }
00773 
00774     }
00775     else {
00776       s << m.rows() << m.cols();
00777       for (j=0; j<m.cols(); j++)
00778         for (i=0; i<m.rows(); i++) {
00779           s << static_cast<double>(m(i,j).real());
00780           s << static_cast<double>(m(i,j).imag());
00781         }
00782     }
00783   }
00784 
00785   void it_file::low_level_write(const Array<float> &v)
00786   {
00787     s << v.size();
00788     for (int i=0; i<v.size(); i++)
00789       s << v(i);
00790   }
00791 
00792   void it_file::low_level_write(const Array<double> &v)
00793   {
00794     if (get_low_precision()) {
00795       s << v.size();
00796       for (int i=0; i<v.size(); i++)
00797         s << static_cast<float>(v(i));
00798     }
00799     else {
00800       s << v.size();
00801       for (int i=0; i<v.size(); i++)
00802         s << static_cast<double>(v(i));
00803     }
00804   }
00805 
00806   void it_file::low_level_write(const Array<int> &v)
00807   {
00808     s << v.size();
00809     for (int i=0; i<v.size(); i++)
00810       s << v(i);
00811   }
00812 
00813   void it_file::low_level_write(const Array<bin> &v)
00814   {
00815     s << v.size();
00816     for (int i=0; i<v.size(); i++)
00817       s << v(i);
00818   }
00819 
00820   void it_file::low_level_write(const Array<std::complex<float> > &v)
00821   {
00822     s << v.size();
00823     for (int i=0; i<v.size(); i++) {
00824       s << v(i).real();
00825       s << v(i).imag();
00826     }
00827   }
00828 
00829   void it_file::low_level_write(const Array<std::complex<double> > &v)
00830   {
00831     if (get_low_precision()) {
00832       s << v.size();
00833       for (int i=0; i<v.size(); i++) {
00834         s << static_cast<float>(v(i).real());
00835         s << static_cast<float>(v(i).imag());
00836       }
00837     }
00838     else {
00839       s << v.size();
00840       for (int i=0; i<v.size(); i++) {
00841         s << static_cast<double>(v(i).real());
00842         s << static_cast<double>(v(i).imag());
00843       }
00844     }
00845   }
00846 
00847   it_ifile &operator>>(it_ifile &f, bin &x)
00848   {
00849     it_file::data_header h;
00850 
00851     f.read_data_header(h);
00852     if (h.type == "bin")
00853       f.low_level_read(x);
00854     else
00855       it_error("Wrong type");
00856 
00857     return f;
00858   }
00859 
00860   it_ifile &operator>>(it_ifile &f, short &x)
00861   {
00862     it_file::data_header h;
00863 
00864     f.read_data_header(h);
00865     if (h.type == "int16")
00866       f.low_level_read(x);
00867     else
00868       it_error("Wrong type");
00869 
00870     return f;
00871   }
00872 
00873   it_ifile &operator>>(it_ifile &f, int &x)
00874   {
00875     it_file::data_header h;
00876 
00877     f.read_data_header(h);
00878     if (h.type == "int32")
00879       f.low_level_read(x);
00880     else if (h.type == "int16") {
00881       short x16;
00882       f.low_level_read(x16);
00883       x = x16;
00884     }
00885     else
00886       it_error("Wrong type");
00887 
00888     return f;
00889   }
00890 
00891   it_ifile &operator>>(it_ifile &f, double &x)
00892   {
00893     it_file::data_header h;
00894 
00895     f.read_data_header(h);
00896     if (h.type == "float64")
00897       f.low_level_read(x);
00898     else if (h.type == "float32") {
00899       float f32;
00900       f.low_level_read(f32);
00901       x = f32;
00902     }
00903     else
00904       it_error("Wrong type");
00905 
00906     return f;
00907   }
00908 
00909   it_ifile &operator>>(it_ifile &f, float &x)
00910   {
00911     it_file::data_header h;
00912 
00913     f.read_data_header(h);
00914     if (h.type == "float32")
00915       f.low_level_read(x);
00916     else
00917       it_error("Wrong type");
00918 
00919     return f;
00920   }
00921 
00922   it_ifile &operator>>(it_ifile &f, std::complex<float> &x)
00923   {
00924     it_file::data_header h;
00925 
00926     f.read_data_header(h);
00927 
00928     if (h.type == "float32_complex") {
00929       std::complex<float> f32_c;
00930       f.low_level_read(f32_c);
00931       x = f32_c;
00932     }
00933     else
00934       it_error("Wrong type");
00935 
00936     return f;
00937   }
00938 
00939   it_ifile &operator>>(it_ifile &f, std::complex<double> &x)
00940   {
00941     it_file::data_header h;
00942 
00943     f.read_data_header(h);
00944     if (h.type == "float64_complex")
00945       f.low_level_read(x);
00946     else if (h.type == "float32_complex") {
00947       std::complex<float> f32_c;
00948       f.low_level_read(f32_c);
00949       x = f32_c;
00950     }
00951     else
00952       it_error("Wrong type");
00953 
00954     return f;
00955   }
00956 
00957   it_ifile &operator>>(it_ifile &f, vec &v)
00958   {
00959     it_ifile::data_header h;
00960 
00961     f.read_data_header(h);
00962     if (h.type == "fvec")
00963       f.low_level_read_lo(v);
00964     else if (h.type == "dvec")
00965       f.low_level_read_hi(v);
00966     else
00967       it_error("Wrong type");
00968 
00969     return f;
00970   }
00971 
00972   it_ifile &operator>>(it_ifile &f, ivec &v)
00973   {
00974     it_file::data_header h;
00975 
00976     f.read_data_header(h);
00977     if (h.type == "ivec")
00978       f.low_level_read(v);
00979     else
00980       it_error("Wrong type");
00981 
00982     return f;
00983   }
00984 
00985   it_ifile &operator>>(it_ifile &f, bvec &v)
00986   {
00987     it_file::data_header h;
00988 
00989     f.read_data_header(h);
00990     if (h.type == "bvec")
00991       f.low_level_read(v);
00992     else
00993       it_error("Wrong type");
00994 
00995     return f;
00996   }
00997 
00998   it_ifile &operator>>(it_ifile &f, cvec &v)
00999   {
01000     it_file::data_header h;
01001 
01002     f.read_data_header(h);
01003     if (h.type == "fcvec")
01004       f.low_level_read_lo(v);
01005     else if (h.type == "dcvec")
01006       f.low_level_read_hi(v);
01007     else
01008       it_error("Wrong type");
01009 
01010     return f;
01011   }
01012 
01013   it_ifile &operator>>(it_ifile &f, std::string &str)
01014   {
01015     it_file::data_header h;
01016 
01017     f.read_data_header(h);
01018     if (h.type == "string")
01019       f.low_level_read(str);
01020     else
01021       it_error("Wrong type");
01022 
01023     return f;
01024   }
01025 
01026   it_ifile &operator>>(it_ifile &f, mat &m)
01027   {
01028     it_file::data_header h;
01029 
01030     f.read_data_header(h);
01031     if (h.type == "fmat")
01032       f.low_level_read_lo(m);
01033     else if (h.type == "dmat")
01034       f.low_level_read_hi(m);
01035     else
01036       it_error("Wrong type");
01037 
01038     return f;
01039   }
01040 
01041   it_ifile &operator>>(it_ifile &f, imat &m)
01042   {
01043     it_file::data_header h;
01044 
01045     f.read_data_header(h);
01046     if (h.type == "imat")
01047       f.low_level_read(m);
01048     else
01049       it_error("Wrong type");
01050 
01051     return f;
01052   }
01053 
01054   it_ifile &operator>>(it_ifile &f, bmat &m)
01055   {
01056     it_file::data_header h;
01057 
01058     f.read_data_header(h);
01059     if (h.type == "bmat")
01060       f.low_level_read(m);
01061     else
01062       it_error("Wrong type");
01063 
01064     return f;
01065   }
01066 
01067   it_ifile &operator>>(it_ifile &f, cmat &m)
01068   {
01069     it_file::data_header h;
01070 
01071     f.read_data_header(h);
01072     if (h.type == "fcmat")
01073       f.low_level_read_lo(m);
01074     else if (h.type == "dcmat")
01075       f.low_level_read_hi(m);
01076     else
01077       it_error("Wrong type");
01078 
01079     return f;
01080   }
01081 
01082   it_ifile &operator>>(it_ifile &f, Array<float> &v)
01083   {
01084     it_file::data_header h;
01085 
01086     f.read_data_header(h);
01087     if (h.type == "fArray")
01088       f.low_level_read_lo(v);
01089     else
01090       it_error("Wrong type");
01091 
01092     return f;
01093   }
01094 
01095   it_ifile &operator>>(it_ifile &f, Array<double> &v)
01096   {
01097     it_file::data_header h;
01098 
01099     f.read_data_header(h);
01100     if (h.type == "fArray")
01101       f.low_level_read_lo(v);
01102     else if (h.type == "dArray")
01103       f.low_level_read_hi(v);
01104     else
01105       it_error("Wrong type");
01106 
01107     return f;
01108   }
01109 
01110   it_ifile &operator>>(it_ifile &f, Array<int> &v)
01111   {
01112     it_file::data_header h;
01113 
01114     f.read_data_header(h);
01115     if (h.type == "iArray")
01116       f.low_level_read(v);
01117     else
01118       it_error("Wrong type");
01119 
01120     return f;
01121   }
01122 
01123   it_ifile &operator>>(it_ifile &f, Array<bin> &v)
01124   {
01125     it_file::data_header h;
01126 
01127     f.read_data_header(h);
01128     if (h.type == "bArray")
01129       f.low_level_read(v);
01130     else
01131       it_error("Wrong type");
01132 
01133     return f;
01134   }
01135 
01136   it_ifile &operator>>(it_ifile &f, Array<std::complex<float> > &v)
01137   {
01138     it_file::data_header h;
01139 
01140     f.read_data_header(h);
01141     if (h.type == "fcArray")
01142       f.low_level_read_lo(v);
01143     else
01144       it_error("Wrong type");
01145 
01146     return f;
01147   }
01148 
01149   it_ifile &operator>>(it_ifile &f, Array<std::complex<double> > &v)
01150   {
01151     it_file::data_header h;
01152 
01153     f.read_data_header(h);
01154     if (h.type == "fcArray")
01155       f.low_level_read_lo(v);
01156     else if (h.type == "dcArray")
01157       f.low_level_read_hi(v);
01158     else
01159       it_error("Wrong type");
01160 
01161     return f;
01162   }
01163 
01164   it_ifile &operator>>(it_ifile &f, Array<vec> &v)
01165   {
01166     it_file::data_header h;
01167 
01168     f.read_data_header(h);
01169     if (h.type == "vecArray") {
01170       int n;
01171       f.low_level_read(n);
01172       v.set_size(n, false);
01173       for (int i=0; i<n; i++)
01174         f.low_level_read_hi(v(i));
01175     }
01176     else
01177       it_error("Wrong type");
01178 
01179     return f;
01180   }
01181 
01182   it_ifile &operator>>(it_ifile &f, Array<ivec> &v)
01183   {
01184     it_file::data_header h;
01185 
01186     f.read_data_header(h);
01187     if (h.type == "ivecArray") {
01188       int n;
01189       f.low_level_read(n);
01190       v.set_size(n, false);
01191       for (int i=0; i<n; i++)
01192         f.low_level_read(v(i));
01193     }
01194     else
01195       it_error("Wrong type");
01196 
01197     return f;
01198   }
01199 
01200   it_ifile &operator>>(it_ifile &f, Array<bvec> &v)
01201   {
01202     it_file::data_header h;
01203 
01204     f.read_data_header(h);
01205     if (h.type == "bvecArray") {
01206       int n;
01207       f.low_level_read(n);
01208       v.set_size(n, false);
01209       for (int i=0; i<n; i++)
01210         f.low_level_read(v(i));
01211     }
01212     else
01213       it_error("Wrong type");
01214 
01215     return f;
01216   }
01217 
01218   it_ifile &operator>>(it_ifile &f, Array<cvec> &v)
01219   {
01220     it_file::data_header h;
01221 
01222     f.read_data_header(h);
01223     if (h.type == "cvecArray") {
01224       int n;
01225       f.low_level_read(n);
01226       v.set_size(n, false);
01227       for (int i=0; i<n; i++)
01228         f.low_level_read_hi(v(i));
01229     }
01230     else
01231       it_error("Wrong type");
01232 
01233     return f;
01234   }
01235 
01236   it_ifile &operator>>(it_ifile &f, Array<std::string> &v)
01237   {
01238     it_file::data_header h;
01239 
01240     f.read_data_header(h);
01241     if (h.type == "stringArray") {
01242       int n;
01243       f.low_level_read(n);
01244       v.set_size(n, false);
01245       for (int i=0; i<n; i++)
01246         f.low_level_read(v(i));
01247     }
01248     else
01249       it_error("Wrong type");
01250 
01251     return f;
01252   }
01253 
01254   it_ifile &operator>>(it_ifile &f, Array<mat> &v)
01255   {
01256     it_file::data_header h;
01257 
01258     f.read_data_header(h);
01259     if (h.type == "matArray") {
01260       int n;
01261       f.low_level_read(n);
01262       v.set_size(n, false);
01263       for (int i=0; i<n; i++)
01264         f.low_level_read_hi(v(i));
01265     }
01266     else
01267       it_error("Wrong type");
01268 
01269     return f;
01270   }
01271 
01272   it_ifile &operator>>(it_ifile &f, Array<imat> &v)
01273   {
01274     it_file::data_header h;
01275 
01276     f.read_data_header(h);
01277     if (h.type == "imatArray") {
01278       int n;
01279       f.low_level_read(n);
01280       v.set_size(n, false);
01281       for (int i=0; i<n; i++)
01282         f.low_level_read(v(i));
01283     }
01284     else
01285       it_error("Wrong type");
01286 
01287     return f;
01288   }
01289 
01290   it_ifile &operator>>(it_ifile &f, Array<bmat> &v)
01291   {
01292     it_file::data_header h;
01293 
01294     f.read_data_header(h);
01295     if (h.type == "bmatArray") {
01296       int n;
01297       f.low_level_read(n);
01298       v.set_size(n, false);
01299       for (int i=0; i<n; i++)
01300         f.low_level_read(v(i));
01301     }
01302     else
01303       it_error("Wrong type");
01304 
01305     return f;
01306   }
01307 
01308   it_ifile &operator>>(it_ifile &f, Array<cmat> &v)
01309   {
01310     it_file::data_header h;
01311 
01312     f.read_data_header(h);
01313     if (h.type == "cmatArray") {
01314       int n;
01315       f.low_level_read(n);
01316       v.set_size(n, false);
01317       for (int i=0; i<n; i++)
01318         f.low_level_read_hi(v(i));
01319     }
01320     else
01321       it_error("Wrong type");
01322 
01323     return f;
01324   }
01325 
01326   it_file &operator<<(it_file &f, bin x)
01327   {
01328     f.write_data_header("bin", sizeof(bin));
01329     f.low_level_write(x);
01330 
01331     return f;
01332   }
01333 
01334   it_file &operator<<(it_file &f, short x)
01335   {
01336     f.write_data_header("int16", sizeof(short));
01337     f.low_level_write(x);
01338 
01339     return f;
01340   }
01341 
01342   it_file &operator<<(it_file &f, int x)
01343   {
01344     f.write_data_header("int32", sizeof(int));
01345     f.low_level_write(x);
01346 
01347     return f;
01348   }
01349 
01350   it_file &operator<<(it_file &f, float x)
01351   {
01352     f.write_data_header("float32", sizeof(float));
01353     f.low_level_write(x);
01354 
01355     return f;
01356   }
01357 
01358   it_file &operator<<(it_file &f, double x)
01359   {
01360     f.write_data_header("float64", sizeof(double));
01361     f.low_level_write(x);
01362 
01363     return f;
01364   }
01365 
01366   it_file &operator<<(it_file &f, std::complex<float> x)
01367   {
01368     f.write_data_header("float32_complex", 2*sizeof(float));
01369     f.low_level_write(x);
01370 
01371     return f;
01372   }
01373 
01374   it_file &operator<<(it_file &f, std::complex<double> x)
01375   {
01376     f.write_data_header("float64_complex", 2*sizeof(double));
01377     f.low_level_write(x);
01378 
01379     return f;
01380   }
01381 
01382   it_file &operator<<(it_file &f, const vec &v)
01383   {
01384     if (f.get_low_precision())
01385       f.write_data_header("fvec", sizeof(int) + v.size() * sizeof(float));
01386     else
01387       f.write_data_header("dvec", sizeof(int) + v.size() * sizeof(double));
01388     f.low_level_write(v);
01389 
01390     return f;
01391   }
01392 
01393   it_file &operator<<(it_file &f, const ivec &v)
01394   {
01395     f.write_data_header("ivec", (1 + v.size()) * sizeof(int));
01396     f.low_level_write(v);
01397 
01398     return f;
01399   }
01400 
01401   it_file &operator<<(it_file &f, const bvec &v)
01402   {
01403     f.write_data_header("bvec", sizeof(int) + v.size() * sizeof(bin) );
01404     f.low_level_write(v);
01405 
01406     return f;
01407   }
01408 
01409   it_file &operator<<(it_file &f, const cvec &v)
01410   {
01411     if (f.get_low_precision())
01412       f.write_data_header("fcvec", sizeof(int) + v.size() * 2 * sizeof(float));
01413     else
01414       f.write_data_header("dcvec", sizeof(int) + v.size() * 2 * sizeof(double));
01415     f.low_level_write(v);
01416 
01417     return f;
01418   }
01419 
01420   it_file &operator<<(it_file &f, const std::string &str)
01421   {
01422     f.write_data_header("string", sizeof(int) + str.size() * sizeof(char) );
01423     f.low_level_write(str);
01424 
01425     return f;
01426   }
01427 
01428   it_file &operator<<(it_file &f, const mat &m)
01429   {
01430     if (f.get_low_precision())
01431       f.write_data_header("fmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(float));
01432     else
01433       f.write_data_header("dmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(double));
01434     f.low_level_write(m);
01435 
01436     return f;
01437   }
01438 
01439   it_file &operator<<(it_file &f, const imat &m)
01440   {
01441     f.write_data_header("imat", (2 + m.rows()*m.cols()) * sizeof(int));
01442     f.low_level_write(m);
01443 
01444     return f;
01445   }
01446 
01447   it_file &operator<<(it_file &f, const bmat &m)
01448   {
01449     f.write_data_header("bmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(bin) );
01450     f.low_level_write(m);
01451 
01452     return f;
01453   }
01454 
01455   it_file &operator<<(it_file &f, const cmat &m)
01456   {
01457     if (f.get_low_precision())
01458       f.write_data_header("fcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(float));
01459     else
01460       f.write_data_header("dcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(double));
01461     f.low_level_write(m);
01462 
01463     return f;
01464   }
01465 
01466   it_file &operator<<(it_file &f, const Array<float> &v)
01467   {
01468     f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
01469     f.low_level_write(v);
01470 
01471     return f;
01472   }
01473 
01474   it_file &operator<<(it_file &f, const Array<double> &v)
01475   {
01476     if (f.get_low_precision())
01477       f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
01478     else
01479       f.write_data_header("dArray", sizeof(int) + v.size() * sizeof(double));
01480     f.low_level_write(v);
01481 
01482     return f;
01483   }
01484 
01485   it_file &operator<<(it_file &f, const Array<int> &v)
01486   {
01487     f.write_data_header("iArray", (1 + v.size()) * sizeof(int));
01488     f.low_level_write(v);
01489 
01490     return f;
01491   }
01492 
01493   it_file &operator<<(it_file &f, const Array<bin> &v)
01494   {
01495     f.write_data_header("bArray", sizeof(int) + v.size() * sizeof(bin) );
01496     f.low_level_write(v);
01497 
01498     return f;
01499   }
01500 
01501   it_file &operator<<(it_file &f, const Array<std::complex<float> > &v)
01502   {
01503     f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
01504     f.low_level_write(v);
01505 
01506     return f;
01507   }
01508 
01509   it_file &operator<<(it_file &f, const Array<std::complex<double> > &v)
01510   {
01511     if (f.get_low_precision())
01512       f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
01513     else
01514       f.write_data_header("dcArray", sizeof(int) + v.size() * 2 * sizeof(double));
01515     f.low_level_write(v);
01516 
01517     return f;
01518   }
01519 
01520   it_file &operator<<(it_file &f, const Array<vec> &v)
01521   {
01522     int i, sum_l=0;
01523 
01524     // calculate total length of Array
01525     for (i=0; i<v.size(); i++) {
01526       sum_l += v(i).size();
01527     }
01528 
01529     // write header
01530     f.write_data_header("vecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(double));
01531 
01532     f.low_level_write(v.size());  // the length of the array
01533 
01534     // write one vector at a time (i.e. size and elements)
01535     for (i=0; i<v.size(); i++)
01536       f.low_level_write(v(i));
01537 
01538     return f;
01539   }
01540 
01541   it_file &operator<<(it_file &f, const Array<ivec> &v)
01542   {
01543     int i, sum_l=0;
01544 
01545     // calculate total length of Array
01546     for (i=0; i<v.size(); i++) {
01547       sum_l += v(i).size();
01548     }
01549 
01550     // write header
01551     f.write_data_header("ivecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(int));
01552 
01553     f.low_level_write(v.size());  // the length of the array
01554 
01555     // write one vector at a time (i.e. size and elements)
01556     for (i=0; i<v.size(); i++)
01557       f.low_level_write(v(i));
01558 
01559     return f;
01560   }
01561 
01562   it_file &operator<<(it_file &f, const Array<bvec> &v)
01563   {
01564     int i, sum_l=0;
01565 
01566     // calculate total length of Array
01567     for (i=0; i<v.size(); i++) {
01568       sum_l += v(i).size();
01569     }
01570 
01571     // write header
01572     f.write_data_header("bvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(bin));
01573 
01574     f.low_level_write(v.size());  // the length of the array
01575 
01576     // write one vector at a time (i.e. size and elements)
01577     for (i=0; i<v.size(); i++)
01578       f.low_level_write(v(i));
01579 
01580     return f;
01581   }
01582 
01583   it_file &operator<<(it_file &f, const Array<cvec> &v)
01584   {
01585     int i, sum_l=0;
01586 
01587     // calculate total length of Array
01588     for (i=0; i<v.size(); i++) {
01589       sum_l += v(i).size();
01590     }
01591 
01592     // write header
01593     f.write_data_header("cvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(std::complex<double>));
01594 
01595     f.low_level_write(v.size());  // the length of the array
01596 
01597     // write one vector at a time (i.e. size and elements)
01598     for (i=0; i<v.size(); i++)
01599       f.low_level_write(v(i));
01600 
01601     return f;
01602   }
01603 
01604   it_file &operator<<(it_file &f, const Array<std::string> &v)
01605   {
01606     int i, sum_l=0;
01607 
01608     // calculate total length of Array
01609     for (i=0; i<v.size(); i++) {
01610       sum_l += v(i).size();
01611     }
01612 
01613     // write header
01614     f.write_data_header("stringArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(char));
01615 
01616     f.low_level_write(v.size());  // the length of the array
01617 
01618     // write one vector at a time (i.e. size and elements)
01619     for (i=0; i<v.size(); i++)
01620       f.low_level_write(v(i));
01621 
01622     return f;
01623   }
01624 
01625   it_file &operator<<(it_file &f, const Array<mat> &v)
01626   {
01627     int i, sum_l=0;
01628 
01629     // calculate total length of Array
01630     for (i=0; i<v.size(); i++) {
01631       sum_l += v(i)._datasize();
01632     }
01633 
01634     // write header
01635     f.write_data_header("matArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(double));
01636 
01637     f.low_level_write(v.size());  // the length of the array
01638 
01639     // write one matrix at a time (i.e. size and elements)
01640     for (i=0; i<v.size(); i++)
01641       f.low_level_write(v(i));
01642 
01643     return f;
01644   }
01645 
01646   it_file &operator<<(it_file &f, const Array<imat> &v)
01647   {
01648     int i, sum_l=0;
01649 
01650     // calculate total length of Array
01651     for (i=0; i<v.size(); i++) {
01652       sum_l += v(i)._datasize();
01653     }
01654 
01655     // write header
01656     f.write_data_header("imatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(int));
01657 
01658     f.low_level_write(v.size());  // the length of the array
01659 
01660     // write one matrix at a time (i.e. size and elements)
01661     for (i=0; i<v.size(); i++)
01662       f.low_level_write(v(i));
01663 
01664     return f;
01665   }
01666 
01667   it_file &operator<<(it_file &f, const Array<bmat> &v)
01668   {
01669     int i, sum_l=0;
01670 
01671     // calculate total length of Array
01672     for (i=0; i<v.size(); i++) {
01673       sum_l += v(i)._datasize();
01674     }
01675 
01676     // write header
01677     f.write_data_header("bmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(bin));
01678 
01679     f.low_level_write(v.size());  // the length of the array
01680 
01681     // write one matrix at a time (i.e. size and elements)
01682     for (i=0; i<v.size(); i++)
01683       f.low_level_write(v(i));
01684 
01685     return f;
01686   }
01687 
01688   it_file &operator<<(it_file &f, const Array<cmat> &v)
01689   {
01690     int i, sum_l=0;
01691 
01692     // calculate total length of Array
01693     for (i=0; i<v.size(); i++) {
01694       sum_l += v(i)._datasize();
01695     }
01696 
01697     // write header
01698     f.write_data_header("cmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(std::complex<double>));
01699 
01700     f.low_level_write(v.size());  // the length of the array
01701 
01702     // write one matrix at a time (i.e. size and elements)
01703     for (i=0; i<v.size(); i++)
01704       f.low_level_write(v(i));
01705 
01706     return f;
01707   }
01708 
01709 } // namespace itpp
SourceForge Logo

Generated on Fri Jun 8 02:08:51 2007 for IT++ by Doxygen 1.5.2