itfile.h

Go to the documentation of this file.

#ifndef ITFILE_H
#define ITFILE_H

#include <itpp/base/vec.h>
#include <itpp/base/array.h>
#include <itpp/base/binfile.h>
#include <itpp/base/itcompat.h>


namespace itpp
{

class it_file_base
{
public:
  struct data_header {
    uint64_t hdr_bytes;
    uint64_t data_bytes;
    uint64_t block_bytes;
    std::string name;
    std::string type;
    std::string desc;
  };

protected:
  struct file_header {
    char magic[4];
    char version;
  };
  static char file_magic[4];
  static char file_version;
};


class it_ifile : public it_file_base
{
public:
  it_ifile();
  explicit it_ifile(const std::string& filename);
  virtual ~it_ifile() { }
  void open(const std::string& filename);
  virtual void close();
  bfstream& low_level() { return s; }

  bool read_check_file_header();
  void read_data_header(data_header& h);

  void low_level_read(char& x);
  void low_level_read(uint64_t& x);
  void low_level_read(bool &x);

  void low_level_read(bin& x);
  void low_level_read(short& x);
  void low_level_read(int& x);
  void low_level_read(float& x);
  void low_level_read(double& x);
  void low_level_read(std::complex<float>& x);
  void low_level_read(std::complex<double>& x);

  void low_level_read(bvec& v);
  void low_level_read(svec& v);
  void low_level_read(ivec& v);
  void low_level_read_lo(vec& v);
  void low_level_read_hi(vec& v);
  void low_level_read_lo(cvec& v);
  void low_level_read_hi(cvec& v);

  void low_level_read(std::string& str);

  void low_level_read(bmat& m);
  void low_level_read(smat& m);
  void low_level_read(imat& m);
  void low_level_read_lo(mat& m);
  void low_level_read_hi(mat& m);
  void low_level_read_lo(cmat& m);
  void low_level_read_hi(cmat& m);

  void low_level_read(Array<bin>& v);
  void low_level_read(Array<short>& v);
  void low_level_read(Array<int>& v);
  void low_level_read(Array<float>& v);
  void low_level_read_lo(Array<double>& v);
  void low_level_read_hi(Array<double>& v);
  void low_level_read(Array<std::complex<float> >& v);
  void low_level_read_lo(Array<std::complex<double> >& v);
  void low_level_read_hi(Array<std::complex<double> >& v);

  bool seek(const std::string& name);
  bool seek(int n);
  void info(std::string& name, std::string& type, std::string& desc,
            uint64_t& bytes);

protected:
  bfstream s;
};


class it_file : public it_ifile
{
public:
  typedef it_file& (*it_manip)(it_file&);

  it_file();

  explicit it_file(const std::string& filename, bool trunc = false);

  virtual ~it_file() { }

  void open(const std::string& filename, bool trunc = false);

  void close();
  void flush();

  bfstream& low_level() { return s; }

  void set_low_precision(bool p = true)  { low_prec = p; }
  bool get_low_precision() const { return low_prec; }

  void set_next_name(const std::string& name,
                     const std::string& description = "")
  { next_name = name; next_desc = description; }

  void write_file_header();
  void write_data_header(const std::string& type, uint64_t size);
  void write_data_header(const std::string& type, const std::string& name,
                         uint64_t size, const std::string& description = "");

  void low_level_write(char x);
  void low_level_write(uint64_t x);
  void low_level_write(bool x);

  void low_level_write(bin x);
  void low_level_write(short x);
  void low_level_write(int x);
  void low_level_write(float x);
  void low_level_write(double x);
  void low_level_write(const std::complex<float>& x);
  void low_level_write(const std::complex<double>& x);

  void low_level_write(const bvec& v);
  void low_level_write(const svec& v);
  void low_level_write(const ivec& v);
  void low_level_write(const vec& v);
  void low_level_write(const cvec& v);

  void low_level_write(const std::string& str);

  void low_level_write(const bmat& m);
  void low_level_write(const smat& m);
  void low_level_write(const imat& m);
  void low_level_write(const mat& m);
  void low_level_write(const cmat& m);

  void low_level_write(const Array<bin>& v);
  void low_level_write(const Array<short>& v);
  void low_level_write(const Array<int>& v);
  void low_level_write(const Array<float>& v);
  void low_level_write(const Array<double>& v);
  void low_level_write(const Array<std::complex<float> >& v);
  void low_level_write(const Array<std::complex<double> >& v);

  it_file& operator<<(it_manip func) { return (*func)(*this); }

  void remove(const std::string& name);
  bool exists(const std::string& name);
  void pack();

protected:
  void remove();
  void write_data_header_here(const data_header& h);

  bool low_prec;
  std::string next_name;
  std::string next_desc;

private:
  // Name of the opened file. Needed by the pack() method.
  std::string fname;
};


inline it_file& flush(it_file& f)
{
  f.flush();
  return f;
}

class Name
{
public:
  Name(const std::string& n, const std::string& d = ""): name(n), desc(d) {}
  Name &operator=(const Name&) { return *this; }
  const std::string& name;
  const std::string& desc;
};




inline it_ifile& operator>>(it_ifile& f, const Name& s)
{
  f.seek(s.name);
  return f;
}

inline it_file& operator<<(it_file& f, const Name& s)
{
  f.set_next_name(s.name, s.desc);
  return f;
}

it_ifile& operator>>(it_ifile& f, char& v);
it_ifile& operator>>(it_ifile &f, bool &v);

it_ifile& operator>>(it_ifile& f, bin& v);
it_ifile& operator>>(it_ifile& f, short& v);
it_ifile& operator>>(it_ifile& f, int& v);
it_ifile& operator>>(it_ifile& f, float& v);
it_ifile& operator>>(it_ifile& f, double& v);
it_ifile& operator>>(it_ifile& f, std::complex<float>& v);
it_ifile& operator>>(it_ifile& f, std::complex<double>& v);

it_ifile& operator>>(it_ifile& f, bvec& v);
it_ifile& operator>>(it_ifile& f, svec& v);
it_ifile& operator>>(it_ifile& f, ivec& v);
it_ifile& operator>>(it_ifile& f, vec& v);
it_ifile& operator>>(it_ifile& f, cvec& v);

it_ifile& operator>>(it_ifile& f, std::string& str);

it_ifile& operator>>(it_ifile& f, bmat& m);
it_ifile& operator>>(it_ifile& f, smat& m);
it_ifile& operator>>(it_ifile& f, imat& m);
it_ifile& operator>>(it_ifile& f, mat& m);
it_ifile& operator>>(it_ifile& f, cmat& m);

it_ifile& operator>>(it_ifile& f, Array<bin>& v);
it_ifile& operator>>(it_ifile& f, Array<short>& v);
it_ifile& operator>>(it_ifile& f, Array<int>& v);
it_ifile& operator>>(it_ifile& f, Array<float>& v);
it_ifile& operator>>(it_ifile& f, Array<double>& v);
it_ifile& operator>>(it_ifile& f, Array<std::complex<float> >& v);
it_ifile& operator>>(it_ifile& f, Array<std::complex<double> >& v);

it_ifile& operator>>(it_ifile& f, Array<bvec>& v);
it_ifile& operator>>(it_ifile& f, Array<svec>& v);
it_ifile& operator>>(it_ifile& f, Array<ivec>& v);
it_ifile& operator>>(it_ifile& f, Array<vec>& v);
it_ifile& operator>>(it_ifile& f, Array<cvec>& v);

it_ifile& operator>>(it_ifile& f, Array<std::string>& v);

it_ifile& operator>>(it_ifile& f, Array<bmat>& v);
it_ifile& operator>>(it_ifile& f, Array<smat>& v);
it_ifile& operator>>(it_ifile& f, Array<imat>& v);
it_ifile& operator>>(it_ifile& f, Array<mat>& v);
it_ifile& operator>>(it_ifile& f, Array<cmat>& v);


it_file& operator<<(it_file& f, char x);
it_file& operator<<(it_file &f, bool x);

it_file& operator<<(it_file& f, bin x);
it_file& operator<<(it_file& f, short x);
it_file& operator<<(it_file& f, int x);
it_file& operator<<(it_file& f, float x);
it_file& operator<<(it_file& f, double x);
it_file& operator<<(it_file& f, std::complex<float> x);
it_file& operator<<(it_file& f, std::complex<double> x);

it_file& operator<<(it_file& f, const bvec& v);
it_file& operator<<(it_file& f, const svec& v);
it_file& operator<<(it_file& f, const ivec& v);
it_file& operator<<(it_file& f, const vec& v);
it_file& operator<<(it_file& f, const cvec& v);

it_file& operator<<(it_file& f, const std::string& str);

it_file& operator<<(it_file& f, const bmat& m);
it_file& operator<<(it_file& f, const smat& m);
it_file& operator<<(it_file& f, const imat& m);
it_file& operator<<(it_file& f, const mat& m);
it_file& operator<<(it_file& f, const cmat& m);

it_file& operator<<(it_file& f, const Array<bin>& v);
it_file& operator<<(it_file& f, const Array<short>& v);
it_file& operator<<(it_file& f, const Array<int>& v);
it_file& operator<<(it_file& f, const Array<float>& v);
it_file& operator<<(it_file& f, const Array<double>& v);
it_file& operator<<(it_file& f, const Array<std::complex<float> >& v);
it_file& operator<<(it_file& f, const Array<std::complex<double> >& v);

it_file& operator<<(it_file& f, const Array<bvec>& v);
it_file& operator<<(it_file& f, const Array<svec>& v);
it_file& operator<<(it_file& f, const Array<ivec>& v);
it_file& operator<<(it_file& f, const Array<vec>& v);
it_file& operator<<(it_file& f, const Array<cvec>& v);

it_file& operator<<(it_file& f, const Array<std::string>& v);

it_file& operator<<(it_file& f, const Array<bmat>& v);
it_file& operator<<(it_file& f, const Array<smat>& v);
it_file& operator<<(it_file& f, const Array<imat>& v);
it_file& operator<<(it_file& f, const Array<mat>& v);
it_file& operator<<(it_file& f, const Array<cmat>& v);

template <class T>
void it_save_var_as(const T& v, const std::string& name)
{
  it_file f(name + ".it");
  f << Name(name) << v;
  f.close();
}

template <class T>
void it_load_var_as(T& v, const std::string& name)
{
  it_ifile f(name + ".it");
  f.seek(name);
  f >> v;
  f.close();
}

#define it_save_var(v) it_save_var_as(v,#v)
#define it_load_var(v) it_load_var_as(v,#v)



// ----------------------------------------------------------------------
// Deprecated implementation of IT++ file format version 2
// Will be removed in future versions
// ----------------------------------------------------------------------

class it_file_base_old
{
public:

  struct data_header {
    char endianity;
    uint32_t hdr_bytes, data_bytes, block_bytes;

    std::string name;
    std::string type;
  };

protected:

  struct file_header {
    char magic[4];
    char version;
  };
  static char file_magic[4];
  static char file_version;
};

class it_ifile_old : public it_file_base_old
{
public:
  it_ifile_old();
  explicit it_ifile_old(const std::string& name);
  virtual ~it_ifile_old() { }
  void open(const std::string& name);
  virtual void close();
  bfstream& low_level() { return s; }

  bool read_check_file_header();
  void read_data_header(data_header& h);
  void low_level_read(char& x);
  void low_level_read(bin& x);
  void low_level_read(short& x);
  void low_level_read(int& x);
  void low_level_read(float& x);
  void low_level_read(double& x);
  void low_level_read(std::complex<float>& x);
  void low_level_read(std::complex<double>& x);
  void low_level_read_lo(vec& v);
  void low_level_read_hi(vec& v);
  void low_level_read(ivec& v);
  void low_level_read(bvec& v);
  void low_level_read_lo(cvec& v);
  void low_level_read_hi(cvec& v);
  void low_level_read(std::string& str);
  void low_level_read_lo(mat& m);
  void low_level_read_hi(mat& m);
  void low_level_read(imat& m);
  void low_level_read(bmat& m);
  void low_level_read_lo(cmat& m);
  void low_level_read_hi(cmat& m);

  void low_level_read_lo(Array<float>& v);
  void low_level_read_lo(Array<double>& v);
  void low_level_read_hi(Array<double>& v);
  void low_level_read(Array<int>& v);
  void low_level_read(Array<bin>& v);
  void low_level_read_lo(Array<std::complex<float> >& v);
  void low_level_read_lo(Array<std::complex<double> >& v);
  void low_level_read_hi(Array<std::complex<double> >& v);

  bool seek(const std::string& name);

  bool seek(int n);
  void info(std::string& name, std::string& type, int& bytes);

protected:
  bfstream s;
};

class it_file_old : public it_ifile_old
{
public:
  typedef it_file_old& (*it_manip)(it_file_old&);

  it_file_old();

  explicit it_file_old(const std::string& name, bool trunc = false);

  virtual ~it_file_old() { }

  void open(const std::string& name, bool trunc = false);

  void close();

  void flush();

  bfstream& low_level() { return s; }

  void set_low_precision(bool p = true)  { low_prec = p; }

  bool get_low_precision() { return low_prec; }

  void set_next_name(const std::string& n) { next_name = n; }

  void write_file_header();
  void write_data_header(const std::string& type, uint32_t size);
  void write_data_header(const std::string& type, const std::string& name,
                         uint32_t size);
  void low_level_write(char x);
  void low_level_write(bin x);
  void low_level_write(short x);
  void low_level_write(int x);
  void low_level_write(float x);
  void low_level_write(double x);
  void low_level_write(const std::complex<float>& x);
  void low_level_write(const std::complex<double>& x);
  void low_level_write(const vec& v);
  void low_level_write(const ivec& v);
  void low_level_write(const bvec& v);
  void low_level_write(const cvec& v);
  void low_level_write(const std::string& str);
  void low_level_write(const mat& m);
  void low_level_write(const imat& m);
  void low_level_write(const bmat& m);
  void low_level_write(const cmat& m);
  void low_level_write(const Array<float>& v);
  void low_level_write(const Array<double>& v);
  void low_level_write(const Array<int>& v);
  void low_level_write(const Array<bin>& v);
  void low_level_write(const Array<std::complex<float> >& v);
  void low_level_write(const Array<std::complex<double> >& v);

  it_file_old& operator<<(it_manip func) { return (*func)(*this); }

  void remove(const std::string& name);
  bool exists(const std::string& name);
  void pack();

protected:
  void remove();
  void write_data_header_here(const data_header& h);

  bool low_prec;
  std::string next_name;
};

inline it_file_old& flush(it_file_old& f)
{
  f.flush();
  return f;
}




inline it_ifile_old& operator>>(it_ifile_old& f, const Name& s)
{
  f.seek(s.name);
  return f;
}

inline it_file_old& operator<<(it_file_old& f, const Name& s)
{
  f.set_next_name(s.name);
  return f;
}

it_ifile_old& operator>>(it_ifile_old& f, char& v);

it_ifile_old& operator>>(it_ifile_old& f, bin& v);

it_ifile_old& operator>>(it_ifile_old& f, short& v);

it_ifile_old& operator>>(it_ifile_old& f, int& v);

it_ifile_old& operator>>(it_ifile_old& f, float& v);

it_ifile_old& operator>>(it_ifile_old& f, double& v);

it_ifile_old& operator>>(it_ifile_old& f, std::complex<float>& v);

it_ifile_old& operator>>(it_ifile_old& f, std::complex<double>& v);

it_ifile_old& operator>>(it_ifile_old& f, vec& v);

it_ifile_old& operator>>(it_ifile_old& f, ivec& v);

it_ifile_old& operator>>(it_ifile_old& f, bvec& v);

it_ifile_old& operator>>(it_ifile_old& f, cvec& v);

it_ifile_old& operator>>(it_ifile_old& f, std::string& str);

it_ifile_old& operator>>(it_ifile_old& f, mat& m);

it_ifile_old& operator>>(it_ifile_old& f, imat& m);

it_ifile_old& operator>>(it_ifile_old& f, bmat& m);

it_ifile_old& operator>>(it_ifile_old& f, cmat& m);

it_ifile_old& operator>>(it_ifile_old& f, Array<float>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<double>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<int>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<bin>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<std::complex<float> >& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<std::complex<double> >& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<vec>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<ivec>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<bvec>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<cvec>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<std::string>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<mat>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<imat>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<bmat>& v);

it_ifile_old& operator>>(it_ifile_old& f, Array<cmat>& v);


it_file_old& operator<<(it_file_old& f, char x);

it_file_old& operator<<(it_file_old& f, bin x);

it_file_old& operator<<(it_file_old& f, short x);

it_file_old& operator<<(it_file_old& f, int x);

it_file_old& operator<<(it_file_old& f, float x);

it_file_old& operator<<(it_file_old& f, double x);

it_file_old& operator<<(it_file_old& f, std::complex<float> x);

it_file_old& operator<<(it_file_old& f, std::complex<double> x);

it_file_old& operator<<(it_file_old& f, const vec& v);

it_file_old& operator<<(it_file_old& f, const ivec& v);

it_file_old& operator<<(it_file_old& f, const bvec& v);

it_file_old& operator<<(it_file_old& f, const cvec& v);

it_file_old& operator<<(it_file_old& f, const std::string& str);

it_file_old& operator<<(it_file_old& f, const mat& m);

it_file_old& operator<<(it_file_old& f, const imat& m);

it_file_old& operator<<(it_file_old& f, const bmat& m);

it_file_old& operator<<(it_file_old& f, const cmat& m);

it_file_old& operator<<(it_file_old& f, const Array<float>& v);

it_file_old& operator<<(it_file_old& f, const Array<double>& v);

it_file_old& operator<<(it_file_old& f, const Array<int>& v);

it_file_old& operator<<(it_file_old& f, const Array<bin>& v);

it_file_old& operator<<(it_file_old& f, const Array<std::complex<float> >& v);

it_file_old& operator<<(it_file_old& f, const Array<std::complex<double> >& v);

it_file_old& operator<<(it_file_old& f, const Array<vec>& v);

it_file_old& operator<<(it_file_old& f, const Array<ivec>& v);

it_file_old& operator<<(it_file_old& f, const Array<bvec>& v);

it_file_old& operator<<(it_file_old& f, const Array<cvec>& v);

it_file_old& operator<<(it_file_old& f, const Array<std::string>& v);

it_file_old& operator<<(it_file_old& f, const Array<mat>& v);

it_file_old& operator<<(it_file_old& f, const Array<imat>& v);

it_file_old& operator<<(it_file_old& f, const Array<bmat>& v);

it_file_old& operator<<(it_file_old& f, const Array<cmat>& v);


// ----------------------------------------------------------------------
// End of the deprecated implementation of IT++ file format version 2
// Will be removed in future versions
// ----------------------------------------------------------------------

} // namespace itpp

#endif // #ifndef IT_FILE_H

---