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     s << str.size();
00718 
00719     for (int i=0; i<(int)str.size(); i++)
00720       s << str[i];
00721   }
00722 
00723   void it_file::low_level_write(const mat &m)
00724   {
00725     int i, j;
00726 
00727     if (get_low_precision()) {
00728       s << m.rows() << m.cols();
00729       for (j=0; j<m.cols(); j++)
00730         for (i=0; i<m.rows(); i++)
00731           s << static_cast<float>(m(i,j));
00732     }
00733     else {
00734       s << m.rows() << m.cols();
00735       for (j=0; j<m.cols(); j++)
00736         for (i=0; i<m.rows(); i++)
00737           s << static_cast<double>(m(i,j));
00738     }
00739   }
00740 
00741   void it_file::low_level_write(const imat &m)
00742   {
00743     int i, j;
00744 
00745     s << m.rows() << m.cols();
00746     for (j=0; j<m.cols(); j++)
00747       for (i=0; i<m.rows(); i++)
00748         s << m(i,j);
00749   }
00750 
00751   void it_file::low_level_write(const bmat &m)
00752   {
00753     int i, j;
00754 
00755     s << m.rows() << m.cols();
00756     for (j=0; j<m.cols(); j++)
00757       for (i=0; i<m.rows(); i++)
00758         s << m(i,j);
00759   }
00760 
00761   void it_file::low_level_write(const cmat &m)
00762   {
00763     int i, j;
00764 
00765     if (get_low_precision()) {
00766       s << m.rows() << m.cols();
00767       for (j=0; j<m.cols(); j++)
00768         for (i=0; i<m.rows(); i++) {
00769           s << static_cast<float>(m(i,j).real());
00770           s << static_cast<float>(m(i,j).imag());
00771         }
00772 
00773     }
00774     else {
00775       s << m.rows() << m.cols();
00776       for (j=0; j<m.cols(); j++)
00777         for (i=0; i<m.rows(); i++) {
00778           s << static_cast<double>(m(i,j).real());
00779           s << static_cast<double>(m(i,j).imag());
00780         }
00781     }
00782   }
00783 
00784   void it_file::low_level_write(const Array<float> &v)
00785   {
00786     s << v.size();
00787     for (int i=0; i<v.size(); i++)
00788       s << v(i);
00789   }
00790 
00791   void it_file::low_level_write(const Array<double> &v)
00792   {
00793     if (get_low_precision()) {
00794       s << v.size();
00795       for (int i=0; i<v.size(); i++)
00796         s << static_cast<float>(v(i));
00797     }
00798     else {
00799       s << v.size();
00800       for (int i=0; i<v.size(); i++)
00801         s << static_cast<double>(v(i));
00802     }
00803   }
00804 
00805   void it_file::low_level_write(const Array<int> &v)
00806   {
00807     s << v.size();
00808     for (int i=0; i<v.size(); i++)
00809       s << v(i);
00810   }
00811 
00812   void it_file::low_level_write(const Array<bin> &v)
00813   {
00814     s << v.size();
00815     for (int i=0; i<v.size(); i++)
00816       s << v(i);
00817   }
00818 
00819   void it_file::low_level_write(const Array<std::complex<float> > &v)
00820   {
00821     s << v.size();
00822     for (int i=0; i<v.size(); i++) {
00823       s << v(i).real();
00824       s << v(i).imag();
00825     }
00826   }
00827 
00828   void it_file::low_level_write(const Array<std::complex<double> > &v)
00829   {
00830     if (get_low_precision()) {
00831       s << v.size();
00832       for (int i=0; i<v.size(); i++) {
00833         s << static_cast<float>(v(i).real());
00834         s << static_cast<float>(v(i).imag());
00835       }
00836     }
00837     else {
00838       s << v.size();
00839       for (int i=0; i<v.size(); i++) {
00840         s << static_cast<double>(v(i).real());
00841         s << static_cast<double>(v(i).imag());
00842       }
00843     }
00844   }
00845 
00846   it_ifile &operator>>(it_ifile &f, bin &x)
00847   {
00848     it_file::data_header h;
00849 
00850     f.read_data_header(h);
00851     if (h.type == "bin")
00852       f.low_level_read(x);
00853     else
00854       it_error("Wrong type");
00855 
00856     return f;
00857   }
00858 
00859   it_ifile &operator>>(it_ifile &f, short &x)
00860   {
00861     it_file::data_header h;
00862 
00863     f.read_data_header(h);
00864     if (h.type == "int16")
00865       f.low_level_read(x);
00866     else
00867       it_error("Wrong type");
00868 
00869     return f;
00870   }
00871 
00872   it_ifile &operator>>(it_ifile &f, int &x)
00873   {
00874     it_file::data_header h;
00875 
00876     f.read_data_header(h);
00877     if (h.type == "int32")
00878       f.low_level_read(x);
00879     else if (h.type == "int16") {
00880       short x16;
00881       f.low_level_read(x16);
00882       x = x16;
00883     }
00884     else
00885       it_error("Wrong type");
00886 
00887     return f;
00888   }
00889 
00890   it_ifile &operator>>(it_ifile &f, double &x)
00891   {
00892     it_file::data_header h;
00893 
00894     f.read_data_header(h);
00895     if (h.type == "float64")
00896       f.low_level_read(x);
00897     else if (h.type == "float32") {
00898       float f32;
00899       f.low_level_read(f32);
00900       x = f32;
00901     }
00902     else
00903       it_error("Wrong type");
00904 
00905     return f;
00906   }
00907 
00908   it_ifile &operator>>(it_ifile &f, float &x)
00909   {
00910     it_file::data_header h;
00911 
00912     f.read_data_header(h);
00913     if (h.type == "float32")
00914       f.low_level_read(x);
00915     else
00916       it_error("Wrong type");
00917 
00918     return f;
00919   }
00920 
00921   it_ifile &operator>>(it_ifile &f, std::complex<float> &x)
00922   {
00923     it_file::data_header h;
00924 
00925     f.read_data_header(h);
00926 
00927     if (h.type == "float32_complex") {
00928       std::complex<float> f32_c;
00929       f.low_level_read(f32_c);
00930       x = f32_c;
00931     }
00932     else
00933       it_error("Wrong type");
00934 
00935     return f;
00936   }
00937 
00938   it_ifile &operator>>(it_ifile &f, std::complex<double> &x)
00939   {
00940     it_file::data_header h;
00941 
00942     f.read_data_header(h);
00943     if (h.type == "float64_complex")
00944       f.low_level_read(x);
00945     else if (h.type == "float32_complex") {
00946       std::complex<float> f32_c;
00947       f.low_level_read(f32_c);
00948       x = f32_c;
00949     }
00950     else
00951       it_error("Wrong type");
00952 
00953     return f;
00954   }
00955 
00956   it_ifile &operator>>(it_ifile &f, vec &v)
00957   {
00958     it_ifile::data_header h;
00959 
00960     f.read_data_header(h);
00961     if (h.type == "fvec")
00962       f.low_level_read_lo(v);
00963     else if (h.type == "dvec")
00964       f.low_level_read_hi(v);
00965     else
00966       it_error("Wrong type");
00967 
00968     return f;
00969   }
00970 
00971   it_ifile &operator>>(it_ifile &f, ivec &v)
00972   {
00973     it_file::data_header h;
00974 
00975     f.read_data_header(h);
00976     if (h.type == "ivec")
00977       f.low_level_read(v);
00978     else
00979       it_error("Wrong type");
00980 
00981     return f;
00982   }
00983 
00984   it_ifile &operator>>(it_ifile &f, bvec &v)
00985   {
00986     it_file::data_header h;
00987 
00988     f.read_data_header(h);
00989     if (h.type == "bvec")
00990       f.low_level_read(v);
00991     else
00992       it_error("Wrong type");
00993 
00994     return f;
00995   }
00996 
00997   it_ifile &operator>>(it_ifile &f, cvec &v)
00998   {
00999     it_file::data_header h;
01000 
01001     f.read_data_header(h);
01002     if (h.type == "fcvec")
01003       f.low_level_read_lo(v);
01004     else if (h.type == "dcvec")
01005       f.low_level_read_hi(v);
01006     else
01007       it_error("Wrong type");
01008 
01009     return f;
01010   }
01011 
01012   it_ifile &operator>>(it_ifile &f, std::string &str)
01013   {
01014     it_file::data_header h;
01015 
01016     f.read_data_header(h);
01017     if (h.type == "string")
01018       f.low_level_read(str);
01019     else
01020       it_error("Wrong type");
01021 
01022     return f;
01023   }
01024 
01025   it_ifile &operator>>(it_ifile &f, mat &m)
01026   {
01027     it_file::data_header h;
01028 
01029     f.read_data_header(h);
01030     if (h.type == "fmat")
01031       f.low_level_read_lo(m);
01032     else if (h.type == "dmat")
01033       f.low_level_read_hi(m);
01034     else
01035       it_error("Wrong type");
01036 
01037     return f;
01038   }
01039 
01040   it_ifile &operator>>(it_ifile &f, imat &m)
01041   {
01042     it_file::data_header h;
01043 
01044     f.read_data_header(h);
01045     if (h.type == "imat")
01046       f.low_level_read(m);
01047     else
01048       it_error("Wrong type");
01049 
01050     return f;
01051   }
01052 
01053   it_ifile &operator>>(it_ifile &f, bmat &m)
01054   {
01055     it_file::data_header h;
01056 
01057     f.read_data_header(h);
01058     if (h.type == "bmat")
01059       f.low_level_read(m);
01060     else
01061       it_error("Wrong type");
01062 
01063     return f;
01064   }
01065 
01066   it_ifile &operator>>(it_ifile &f, cmat &m)
01067   {
01068     it_file::data_header h;
01069 
01070     f.read_data_header(h);
01071     if (h.type == "fcmat")
01072       f.low_level_read_lo(m);
01073     else if (h.type == "dcmat")
01074       f.low_level_read_hi(m);
01075     else
01076       it_error("Wrong type");
01077 
01078     return f;
01079   }
01080 
01081   it_ifile &operator>>(it_ifile &f, Array<float> &v)
01082   {
01083     it_file::data_header h;
01084 
01085     f.read_data_header(h);
01086     if (h.type == "fArray")
01087       f.low_level_read_lo(v);
01088     else
01089       it_error("Wrong type");
01090 
01091     return f;
01092   }
01093 
01094   it_ifile &operator>>(it_ifile &f, Array<double> &v)
01095   {
01096     it_file::data_header h;
01097 
01098     f.read_data_header(h);
01099     if (h.type == "fArray")
01100       f.low_level_read_lo(v);
01101     else if (h.type == "dArray")
01102       f.low_level_read_hi(v);
01103     else
01104       it_error("Wrong type");
01105 
01106     return f;
01107   }
01108 
01109   it_ifile &operator>>(it_ifile &f, Array<int> &v)
01110   {
01111     it_file::data_header h;
01112 
01113     f.read_data_header(h);
01114     if (h.type == "iArray")
01115       f.low_level_read(v);
01116     else
01117       it_error("Wrong type");
01118 
01119     return f;
01120   }
01121 
01122   it_ifile &operator>>(it_ifile &f, Array<bin> &v)
01123   {
01124     it_file::data_header h;
01125 
01126     f.read_data_header(h);
01127     if (h.type == "bArray")
01128       f.low_level_read(v);
01129     else
01130       it_error("Wrong type");
01131 
01132     return f;
01133   }
01134 
01135   it_ifile &operator>>(it_ifile &f, Array<std::complex<float> > &v)
01136   {
01137     it_file::data_header h;
01138 
01139     f.read_data_header(h);
01140     if (h.type == "fcArray")
01141       f.low_level_read_lo(v);
01142     else
01143       it_error("Wrong type");
01144 
01145     return f;
01146   }
01147 
01148   it_ifile &operator>>(it_ifile &f, Array<std::complex<double> > &v)
01149   {
01150     it_file::data_header h;
01151 
01152     f.read_data_header(h);
01153     if (h.type == "fcArray")
01154       f.low_level_read_lo(v);
01155     else if (h.type == "dcArray")
01156       f.low_level_read_hi(v);
01157     else
01158       it_error("Wrong type");
01159 
01160     return f;
01161   }
01162 
01163   it_ifile &operator>>(it_ifile &f, Array<vec> &v)
01164   {
01165     it_file::data_header h;
01166 
01167     f.read_data_header(h);
01168     if (h.type == "vecArray") {
01169       int n;
01170       f.low_level_read(n);
01171       v.set_size(n, false);
01172       for (int i=0; i<n; i++)
01173         f.low_level_read_hi(v(i));
01174     }
01175     else
01176       it_error("Wrong type");
01177 
01178     return f;
01179   }
01180 
01181   it_ifile &operator>>(it_ifile &f, Array<ivec> &v)
01182   {
01183     it_file::data_header h;
01184 
01185     f.read_data_header(h);
01186     if (h.type == "ivecArray") {
01187       int n;
01188       f.low_level_read(n);
01189       v.set_size(n, false);
01190       for (int i=0; i<n; i++)
01191         f.low_level_read(v(i));
01192     }
01193     else
01194       it_error("Wrong type");
01195 
01196     return f;
01197   }
01198 
01199   it_ifile &operator>>(it_ifile &f, Array<bvec> &v)
01200   {
01201     it_file::data_header h;
01202 
01203     f.read_data_header(h);
01204     if (h.type == "bvecArray") {
01205       int n;
01206       f.low_level_read(n);
01207       v.set_size(n, false);
01208       for (int i=0; i<n; i++)
01209         f.low_level_read(v(i));
01210     }
01211     else
01212       it_error("Wrong type");
01213 
01214     return f;
01215   }
01216 
01217   it_ifile &operator>>(it_ifile &f, Array<cvec> &v)
01218   {
01219     it_file::data_header h;
01220 
01221     f.read_data_header(h);
01222     if (h.type == "cvecArray") {
01223       int n;
01224       f.low_level_read(n);
01225       v.set_size(n, false);
01226       for (int i=0; i<n; i++)
01227         f.low_level_read_hi(v(i));
01228     }
01229     else
01230       it_error("Wrong type");
01231 
01232     return f;
01233   }
01234 
01235   it_ifile &operator>>(it_ifile &f, Array<std::string> &v)
01236   {
01237     it_file::data_header h;
01238 
01239     f.read_data_header(h);
01240     if (h.type == "stringArray") {
01241       int n;
01242       f.low_level_read(n);
01243       v.set_size(n, false);
01244       for (int i=0; i<n; i++)
01245         f.low_level_read(v(i));
01246     }
01247     else
01248       it_error("Wrong type");
01249 
01250     return f;
01251   }
01252 
01253   it_ifile &operator>>(it_ifile &f, Array<mat> &v)
01254   {
01255     it_file::data_header h;
01256 
01257     f.read_data_header(h);
01258     if (h.type == "matArray") {
01259       int n;
01260       f.low_level_read(n);
01261       v.set_size(n, false);
01262       for (int i=0; i<n; i++)
01263         f.low_level_read_hi(v(i));
01264     }
01265     else
01266       it_error("Wrong type");
01267 
01268     return f;
01269   }
01270 
01271   it_ifile &operator>>(it_ifile &f, Array<imat> &v)
01272   {
01273     it_file::data_header h;
01274 
01275     f.read_data_header(h);
01276     if (h.type == "imatArray") {
01277       int n;
01278       f.low_level_read(n);
01279       v.set_size(n, false);
01280       for (int i=0; i<n; i++)
01281         f.low_level_read(v(i));
01282     }
01283     else
01284       it_error("Wrong type");
01285 
01286     return f;
01287   }
01288 
01289   it_ifile &operator>>(it_ifile &f, Array<bmat> &v)
01290   {
01291     it_file::data_header h;
01292 
01293     f.read_data_header(h);
01294     if (h.type == "bmatArray") {
01295       int n;
01296       f.low_level_read(n);
01297       v.set_size(n, false);
01298       for (int i=0; i<n; i++)
01299         f.low_level_read(v(i));
01300     }
01301     else
01302       it_error("Wrong type");
01303 
01304     return f;
01305   }
01306 
01307   it_ifile &operator>>(it_ifile &f, Array<cmat> &v)
01308   {
01309     it_file::data_header h;
01310 
01311     f.read_data_header(h);
01312     if (h.type == "cmatArray") {
01313       int n;
01314       f.low_level_read(n);
01315       v.set_size(n, false);
01316       for (int i=0; i<n; i++)
01317         f.low_level_read_hi(v(i));
01318     }
01319     else
01320       it_error("Wrong type");
01321 
01322     return f;
01323   }
01324 
01325   it_file &operator<<(it_file &f, bin x)
01326   {
01327     f.write_data_header("bin", sizeof(bin));
01328     f.low_level_write(x);
01329 
01330     return f;
01331   }
01332 
01333   it_file &operator<<(it_file &f, short x)
01334   {
01335     f.write_data_header("int16", sizeof(short));
01336     f.low_level_write(x);
01337 
01338     return f;
01339   }
01340 
01341   it_file &operator<<(it_file &f, int x)
01342   {
01343     f.write_data_header("int32", sizeof(int));
01344     f.low_level_write(x);
01345 
01346     return f;
01347   }
01348 
01349   it_file &operator<<(it_file &f, float x)
01350   {
01351     f.write_data_header("float32", sizeof(float));
01352     f.low_level_write(x);
01353 
01354     return f;
01355   }
01356 
01357   it_file &operator<<(it_file &f, double x)
01358   {
01359     f.write_data_header("float64", sizeof(double));
01360     f.low_level_write(x);
01361 
01362     return f;
01363   }
01364 
01365   it_file &operator<<(it_file &f, std::complex<float> x)
01366   {
01367     f.write_data_header("float32_complex", 2*sizeof(float));
01368     f.low_level_write(x);
01369 
01370     return f;
01371   }
01372 
01373   it_file &operator<<(it_file &f, std::complex<double> x)
01374   {
01375     f.write_data_header("float64_complex", 2*sizeof(double));
01376     f.low_level_write(x);
01377 
01378     return f;
01379   }
01380 
01381   it_file &operator<<(it_file &f, const vec &v)
01382   {
01383     if (f.get_low_precision())
01384       f.write_data_header("fvec", sizeof(int) + v.size() * sizeof(float));
01385     else
01386       f.write_data_header("dvec", sizeof(int) + v.size() * sizeof(double));
01387     f.low_level_write(v);
01388 
01389     return f;
01390   }
01391 
01392   it_file &operator<<(it_file &f, const ivec &v)
01393   {
01394     f.write_data_header("ivec", (1 + v.size()) * sizeof(int));
01395     f.low_level_write(v);
01396 
01397     return f;
01398   }
01399 
01400   it_file &operator<<(it_file &f, const bvec &v)
01401   {
01402     f.write_data_header("bvec", sizeof(int) + v.size() * sizeof(bin) );
01403     f.low_level_write(v);
01404 
01405     return f;
01406   }
01407 
01408   it_file &operator<<(it_file &f, const cvec &v)
01409   {
01410     if (f.get_low_precision())
01411       f.write_data_header("fcvec", sizeof(int) + v.size() * 2 * sizeof(float));
01412     else
01413       f.write_data_header("dcvec", sizeof(int) + v.size() * 2 * sizeof(double));
01414     f.low_level_write(v);
01415 
01416     return f;
01417   }
01418 
01419   it_file &operator<<(it_file &f, const std::string &str)
01420   {
01421     f.write_data_header("string", sizeof(int) + str.size() * sizeof(char) );
01422     f.low_level_write(str);
01423 
01424     return f;
01425   }
01426 
01427   it_file &operator<<(it_file &f, const mat &m)
01428   {
01429     if (f.get_low_precision())
01430       f.write_data_header("fmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(float));
01431     else
01432       f.write_data_header("dmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(double));
01433     f.low_level_write(m);
01434 
01435     return f;
01436   }
01437 
01438   it_file &operator<<(it_file &f, const imat &m)
01439   {
01440     f.write_data_header("imat", (2 + m.rows()*m.cols()) * sizeof(int));
01441     f.low_level_write(m);
01442 
01443     return f;
01444   }
01445 
01446   it_file &operator<<(it_file &f, const bmat &m)
01447   {
01448     f.write_data_header("bmat", 2*sizeof(int) + m.rows()*m.cols()*sizeof(bin) );
01449     f.low_level_write(m);
01450 
01451     return f;
01452   }
01453 
01454   it_file &operator<<(it_file &f, const cmat &m)
01455   {
01456     if (f.get_low_precision())
01457       f.write_data_header("fcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(float));
01458     else
01459       f.write_data_header("dcmat", 2*sizeof(int) + 2*m.rows()*m.cols()*sizeof(double));
01460     f.low_level_write(m);
01461 
01462     return f;
01463   }
01464 
01465   it_file &operator<<(it_file &f, const Array<float> &v)
01466   {
01467     f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
01468     f.low_level_write(v);
01469 
01470     return f;
01471   }
01472 
01473   it_file &operator<<(it_file &f, const Array<double> &v)
01474   {
01475     if (f.get_low_precision())
01476       f.write_data_header("fArray", sizeof(int) + v.size() * sizeof(float));
01477     else
01478       f.write_data_header("dArray", sizeof(int) + v.size() * sizeof(double));
01479     f.low_level_write(v);
01480 
01481     return f;
01482   }
01483 
01484   it_file &operator<<(it_file &f, const Array<int> &v)
01485   {
01486     f.write_data_header("iArray", (1 + v.size()) * sizeof(int));
01487     f.low_level_write(v);
01488 
01489     return f;
01490   }
01491 
01492   it_file &operator<<(it_file &f, const Array<bin> &v)
01493   {
01494     f.write_data_header("bArray", sizeof(int) + v.size() * sizeof(bin) );
01495     f.low_level_write(v);
01496 
01497     return f;
01498   }
01499 
01500   it_file &operator<<(it_file &f, const Array<std::complex<float> > &v)
01501   {
01502     f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
01503     f.low_level_write(v);
01504 
01505     return f;
01506   }
01507 
01508   it_file &operator<<(it_file &f, const Array<std::complex<double> > &v)
01509   {
01510     if (f.get_low_precision())
01511       f.write_data_header("fcArray", sizeof(int) + v.size() * 2 * sizeof(float));
01512     else
01513       f.write_data_header("dcArray", sizeof(int) + v.size() * 2 * sizeof(double));
01514     f.low_level_write(v);
01515 
01516     return f;
01517   }
01518 
01519   it_file &operator<<(it_file &f, const Array<vec> &v)
01520   {
01521     int i, sum_l=0;
01522 
01523     // calculate total length of Array
01524     for (i=0; i<v.size(); i++) {
01525       sum_l += v(i).size();
01526     }
01527 
01528     // write header
01529     f.write_data_header("vecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(double));
01530 
01531     f.low_level_write(v.size());  // the length of the array
01532 
01533     // write one vector at a time (i.e. size and elements)
01534     for (i=0; i<v.size(); i++)
01535       f.low_level_write(v(i));
01536 
01537     return f;
01538   }
01539 
01540   it_file &operator<<(it_file &f, const Array<ivec> &v)
01541   {
01542     int i, sum_l=0;
01543 
01544     // calculate total length of Array
01545     for (i=0; i<v.size(); i++) {
01546       sum_l += v(i).size();
01547     }
01548 
01549     // write header
01550     f.write_data_header("ivecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(int));
01551 
01552     f.low_level_write(v.size());  // the length of the array
01553 
01554     // write one vector at a time (i.e. size and elements)
01555     for (i=0; i<v.size(); i++)
01556       f.low_level_write(v(i));
01557 
01558     return f;
01559   }
01560 
01561   it_file &operator<<(it_file &f, const Array<bvec> &v)
01562   {
01563     int i, sum_l=0;
01564 
01565     // calculate total length of Array
01566     for (i=0; i<v.size(); i++) {
01567       sum_l += v(i).size();
01568     }
01569 
01570     // write header
01571     f.write_data_header("bvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(bin));
01572 
01573     f.low_level_write(v.size());  // the length of the array
01574 
01575     // write one vector at a time (i.e. size and elements)
01576     for (i=0; i<v.size(); i++)
01577       f.low_level_write(v(i));
01578 
01579     return f;
01580   }
01581 
01582   it_file &operator<<(it_file &f, const Array<cvec> &v)
01583   {
01584     int i, sum_l=0;
01585 
01586     // calculate total length of Array
01587     for (i=0; i<v.size(); i++) {
01588       sum_l += v(i).size();
01589     }
01590 
01591     // write header
01592     f.write_data_header("cvecArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(std::complex<double>));
01593 
01594     f.low_level_write(v.size());  // the length of the array
01595 
01596     // write one vector at a time (i.e. size and elements)
01597     for (i=0; i<v.size(); i++)
01598       f.low_level_write(v(i));
01599 
01600     return f;
01601   }
01602 
01603   it_file &operator<<(it_file &f, const Array<std::string> &v)
01604   {
01605     int i, sum_l=0;
01606 
01607     // calculate total length of Array
01608     for (i=0; i<v.size(); i++) {
01609       sum_l += v(i).size();
01610     }
01611 
01612     // write header
01613     f.write_data_header("stringArray", sizeof(int)*(1+v.size()) + sum_l * sizeof(char));
01614 
01615     f.low_level_write(v.size());  // the length of the array
01616 
01617     // write one vector at a time (i.e. size and elements)
01618     for (i=0; i<v.size(); i++)
01619       f.low_level_write(v(i));
01620 
01621     return f;
01622   }
01623 
01624   it_file &operator<<(it_file &f, const Array<mat> &v)
01625   {
01626     int i, sum_l=0;
01627 
01628     // calculate total length of Array
01629     for (i=0; i<v.size(); i++) {
01630       sum_l += v(i)._datasize();
01631     }
01632 
01633     // write header
01634     f.write_data_header("matArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(double));
01635 
01636     f.low_level_write(v.size());  // the length of the array
01637 
01638     // write one matrix at a time (i.e. size and elements)
01639     for (i=0; i<v.size(); i++)
01640       f.low_level_write(v(i));
01641 
01642     return f;
01643   }
01644 
01645   it_file &operator<<(it_file &f, const Array<imat> &v)
01646   {
01647     int i, sum_l=0;
01648 
01649     // calculate total length of Array
01650     for (i=0; i<v.size(); i++) {
01651       sum_l += v(i)._datasize();
01652     }
01653 
01654     // write header
01655     f.write_data_header("imatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(int));
01656 
01657     f.low_level_write(v.size());  // the length of the array
01658 
01659     // write one matrix at a time (i.e. size and elements)
01660     for (i=0; i<v.size(); i++)
01661       f.low_level_write(v(i));
01662 
01663     return f;
01664   }
01665 
01666   it_file &operator<<(it_file &f, const Array<bmat> &v)
01667   {
01668     int i, sum_l=0;
01669 
01670     // calculate total length of Array
01671     for (i=0; i<v.size(); i++) {
01672       sum_l += v(i)._datasize();
01673     }
01674 
01675     // write header
01676     f.write_data_header("bmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(bin));
01677 
01678     f.low_level_write(v.size());  // the length of the array
01679 
01680     // write one matrix at a time (i.e. size and elements)
01681     for (i=0; i<v.size(); i++)
01682       f.low_level_write(v(i));
01683 
01684     return f;
01685   }
01686 
01687   it_file &operator<<(it_file &f, const Array<cmat> &v)
01688   {
01689     int i, sum_l=0;
01690 
01691     // calculate total length of Array
01692     for (i=0; i<v.size(); i++) {
01693       sum_l += v(i)._datasize();
01694     }
01695 
01696     // write header
01697     f.write_data_header("cmatArray", sizeof(int)*(1+2*v.size()) + sum_l * sizeof(std::complex<double>));
01698 
01699     f.low_level_write(v.size());  // the length of the array
01700 
01701     // write one matrix at a time (i.e. size and elements)
01702     for (i=0; i<v.size(); i++)
01703       f.low_level_write(v(i));
01704 
01705     return f;
01706   }
01707 
01708 } // namespace itpp
SourceForge Logo

Generated on Wed Mar 21 12:21:34 2007 for IT++ by Doxygen 1.4.7