binfile.h

Go to the documentation of this file.

#ifndef BINFILE_H
#define BINFILE_H

#include <itpp/itexports.h>

#include <itpp/base/ittypes.h>
#include <itpp/base/binary.h>
#include <fstream>

#ifdef _MSC_VER
#pragma warning( disable : 4250 )
#endif

namespace itpp
{

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

class ITPP_EXPORT bfstream_base
{
public:
  enum endian { l_endian, b_endian };

  bfstream_base(endian e = b_endian);

  endian get_endianity() const {
    if (switch_endianity) {
      if (native_endianity == l_endian)
        return b_endian;
      else
        return l_endian;
    }
    else
      return native_endianity;
  }

  endian get_native_endianity() const { return native_endianity; }

  void set_endianity(endian e) {
    if (native_endianity == e)
      switch_endianity = false;
    else
      switch_endianity = true;
  }

  void set_native_endianity() { switch_endianity = false; }

protected:
  bool switch_endianity;
  endian native_endianity;
};

namespace binfile_details
{
  class ITPP_EXPORT Ofstream_Binfile_Facade
  {
    std::ofstream* _str;
    //following makes class non-copiable
    Ofstream_Binfile_Facade(const Ofstream_Binfile_Facade& o);
    void operator= (const Ofstream_Binfile_Facade& o);
  public:
    Ofstream_Binfile_Facade ( );
    explicit Ofstream_Binfile_Facade ( const char * filename,
      std::ios_base::openmode mode = std::ios_base::out | std::ios_base::binary);
    bool is_open() {return _str->is_open();}
    void open ( const char * filename,
      std::ios_base::openmode mode = std::ios_base::out | std::ios_base::binary )
    {_str->open(filename,mode);}
    void close()
    {_str->close();}
    Ofstream_Binfile_Facade& write (const char* c, std::streamsize n)
    {_str->write(c,n); return *this;}
    Ofstream_Binfile_Facade& put (const char c)
    {_str->put(c); return *this;};
    std::streampos tellp()
    {return _str->tellp();}
    Ofstream_Binfile_Facade& seekp (std::streampos pos)
    {_str->seekp(pos); return *this;}
    Ofstream_Binfile_Facade& seekp (std::streamoff pos, std::ios_base::seekdir way)
    {_str->seekp(pos,way); return *this;}
    Ofstream_Binfile_Facade& flush()
    {_str->flush(); return *this;}

    bool good() const {return _str->good();}
    bool eof() const {return _str->eof();}
    bool fail() const {return _str->fail();}
    bool bad() const {return _str->bad();}

    bool operator!() const {return _str->fail();}
    operator bool() const {return _str->good();}

    std::ios_base::iostate rdstate() const {return _str->rdstate();}
    void setstate (std::ios_base::iostate state) {_str->setstate(state);}
    void clear (std::ios_base::iostate state = std::ios_base::goodbit) {_str->clear(state);}
    std::ios_base::iostate exceptions() const {return _str->exceptions();}
    void exceptions (std::ios_base::iostate except) {_str->exceptions(except);}

    virtual ~Ofstream_Binfile_Facade();
  protected:
    std::ofstream* stream() {return _str;}
  };

  class ITPP_EXPORT Ifstream_Binfile_Facade
  {
    std::ifstream* _str;
    //following makes class non-copiable
    Ifstream_Binfile_Facade(const Ifstream_Binfile_Facade& o);
    void operator= (const Ifstream_Binfile_Facade& o);
  public:
    Ifstream_Binfile_Facade ( );
    explicit Ifstream_Binfile_Facade ( const char * filename,
      std::ios_base::openmode mode = std::ios_base::in | std::ios_base::binary);
    bool is_open()
    {return _str->is_open();}
    void open ( const char * filename,
      std::ios_base::openmode mode = std::ios_base::in | std::ios_base::binary)
    {_str->open(filename,mode);}
    void close() {_str->close();}
    std::streamsize gcount() const {return _str->gcount();}
    int get() {return _str->get();}
    Ifstream_Binfile_Facade& get(char& c) {_str->get(c); return *this;}
    Ifstream_Binfile_Facade& get (char* s, std::streamsize n)
    {_str->get(s,n); return *this;}
    Ifstream_Binfile_Facade& get (char* s, std::streamsize n, char delim)
    {_str->get(s,n,delim); return *this;}
    Ifstream_Binfile_Facade& getline (char* s, std::streamsize n )
    {_str->getline(s,n); return *this;}
    Ifstream_Binfile_Facade& getline (char* s, std::streamsize n, char delim )
    {_str->getline(s,n,delim); return *this;}
    Ifstream_Binfile_Facade& ignore (std::streamsize n = 1, int delim = EOF)
    {_str->ignore(n,delim); return *this;}
    int peek() {return _str->peek();}
    Ifstream_Binfile_Facade& read (char* s, std::streamsize n)
    {_str->read(s,n); return *this;}
    std::streamsize readsome (char* s, std::streamsize n)
    {return _str->readsome(s,n);}
    Ifstream_Binfile_Facade& putback (char c)
    {_str->putback(c); return *this;}
    Ifstream_Binfile_Facade& unget()  {_str->unget(); return *this;}
    std::streampos tellg() {return _str->tellg();}
    Ifstream_Binfile_Facade& seekg (std::streampos pos)
    {_str->seekg(pos); return *this;}
    Ifstream_Binfile_Facade& seekg (std::streamoff pos, std::ios_base::seekdir way)
    {_str->seekg(pos,way); return *this;}

    bool good() const {return _str->good();}
    bool eof() const {return _str->eof();}
    bool fail() const {return _str->fail();}
    bool bad() const {return _str->bad();}

    bool operator!() const {return _str->fail();}
    operator bool() const {return _str->good();}

    std::ios_base::iostate rdstate() const {return _str->rdstate();}
    void setstate (std::ios_base::iostate state) {_str->setstate(state);}
    void clear (std::ios_base::iostate state = std::ios_base::goodbit) {_str->clear(state);}
    std::ios_base::iostate exceptions() const {return _str->exceptions();}
    void exceptions (std::ios_base::iostate except) {_str->exceptions(except);}

    virtual ~Ifstream_Binfile_Facade();
  protected:
    std::ifstream* stream() {return _str;}
  };

  class ITPP_EXPORT Fstream_Binfile_Facade
  {
    std::fstream* _str;
    //following makes class non-copiable
    Fstream_Binfile_Facade(const Fstream_Binfile_Facade& o);
    void operator= (const Fstream_Binfile_Facade& o);
  public:
    Fstream_Binfile_Facade ( );
    explicit Fstream_Binfile_Facade ( const char * filename,
      std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out | std::ios_base::binary);
    bool is_open() {return _str->is_open();}
    void open ( const char * filename,
      std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out | std::ios_base::binary)
    {_str->open(filename,mode);}
    void close() {_str->close();}

    Fstream_Binfile_Facade& write (const char* c, std::streamsize n)
    {_str->write(c,n); return *this;};
    Fstream_Binfile_Facade& put (const char c)
    {_str->put(c); return *this;};
    std::streampos tellp() {return _str->tellp();}
    Fstream_Binfile_Facade& seekp (std::streampos pos)
    {_str->seekp(pos); return *this;}
    Fstream_Binfile_Facade& seekp (std::streamoff pos, std::ios_base::seekdir way)
    {_str->seekp(pos,way); return *this;}
    Fstream_Binfile_Facade& flush() {_str->flush(); return *this;}
    std::streamsize gcount() const {return _str->gcount();}
    int get() {return _str->get();}
    Fstream_Binfile_Facade& get(char& c){_str->get(c); return *this;}
    Fstream_Binfile_Facade& get(char* s, std::streamsize n)
    {_str->get(s,n); return *this;}
    Fstream_Binfile_Facade& get(char* s, std::streamsize n, char delim)
    {_str->get(s,n,delim); return *this;}
    Fstream_Binfile_Facade& getline(char* s, std::streamsize n)
    {_str->getline(s,n); return *this;}
    Fstream_Binfile_Facade& getline(char* s, std::streamsize n, char delim)
    {_str->getline(s,n,delim); return *this;}
    Fstream_Binfile_Facade& ignore (std::streamsize n = 1, int delim = EOF)
    {_str->ignore(n,delim); return *this;}
    int peek() {return _str->peek();}
    Fstream_Binfile_Facade& read (char* s, std::streamsize n)
    {_str->read(s,n); return *this;}
    std::streamsize readsome (char* s, std::streamsize n)
    {return _str->readsome(s,n);}
    Fstream_Binfile_Facade& putback (char c)
    {_str->putback(c); return *this;}
    Fstream_Binfile_Facade& unget()
    {_str->unget(); return *this;}
    std::streampos tellg() {return _str->tellg();}
    Fstream_Binfile_Facade& seekg (std::streampos pos)
    {_str->seekg(pos); return *this;}
    Fstream_Binfile_Facade& seekg (std::streamoff pos, std::ios_base::seekdir way)
    {_str->seekg(pos,way); return *this;}

    bool good() const {return _str->good();}
    bool eof() const {return _str->eof();}
    bool fail() const {return _str->fail();}
    bool bad() const {return _str->bad();}

    bool operator!() const {return _str->fail();}
    operator bool() const {return _str->good();}

    std::ios_base::iostate rdstate() const {return _str->rdstate();}
    void setstate (std::ios_base::iostate state) {_str->setstate(state);}
    void clear (std::ios_base::iostate state = std::ios_base::goodbit)
    {_str->clear(state);}
    std::ios_base::iostate exceptions() const {return _str->exceptions();}
    void exceptions (std::ios_base::iostate except) {_str->exceptions(except);}

    virtual ~Fstream_Binfile_Facade();
  protected:
    std::fstream* stream() {return _str;}
  };


}

class ITPP_EXPORT bofstream : public bfstream_base, public binfile_details::Ofstream_Binfile_Facade
{
public:
  bofstream(const std::string& name, endian e = b_endian);

  bofstream();

  ~bofstream() { }

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

  bofstream& operator<<(char a);
  bofstream& operator<<(int8_t a);
  bofstream& operator<<(uint8_t a);
  bofstream& operator<<(int16_t a);
  bofstream& operator<<(uint16_t a);
  bofstream& operator<<(int32_t a);
  bofstream& operator<<(uint32_t a);
  bofstream& operator<<(int64_t a);
  bofstream& operator<<(uint64_t a);
  bofstream& operator<<(float a);
  bofstream& operator<<(double a);
  bofstream& operator<<(bin a);
  bofstream& operator<<(const char* a);
  bofstream& operator<<(const std::string& a);
};

class ITPP_EXPORT bifstream : public bfstream_base, public binfile_details::Ifstream_Binfile_Facade
{
public:
  bifstream(const std::string& name, endian e = b_endian);

  bifstream();

  ~bifstream() { }

  void open(const std::string& name, endian e = b_endian);

  int length();

  bifstream& operator>>(char& a);
  bifstream& operator>>(int8_t& a);
  bifstream& operator>>(uint8_t& a);
  bifstream& operator>>(int16_t& a);
  bifstream& operator>>(uint16_t& a);
  bifstream& operator>>(int32_t& a);
  bifstream& operator>>(uint32_t& a);
  bifstream& operator>>(int64_t& a);
  bifstream& operator>>(uint64_t& a);
  bifstream& operator>>(float& a);
  bifstream& operator>>(double& a);
  bifstream& operator>>(bin& a);
  bifstream& operator>>(char* a);
  bifstream& operator>>(std::string& a);
};

class ITPP_EXPORT bfstream : public bfstream_base, public binfile_details::Fstream_Binfile_Facade
{
public:
  bfstream(const std::string& name, endian e = b_endian);

  bfstream();

  ~bfstream() { }

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

  void open_readonly(const std::string& name, endian e = b_endian);

  int length();

  bfstream& operator<<(char a);
  bfstream& operator<<(int8_t a);
  bfstream& operator<<(uint8_t a);
  bfstream& operator<<(int16_t a);
  bfstream& operator<<(uint16_t a);
  bfstream& operator<<(int32_t a);
  bfstream& operator<<(uint32_t a);
  bfstream& operator<<(int64_t a);
  bfstream& operator<<(uint64_t a);
  bfstream& operator<<(float a);
  bfstream& operator<<(double a);
  bfstream& operator<<(bin a);
  bfstream& operator<<(const char* a);
  bfstream& operator<<(const std::string& a);

  bfstream& operator>>(char& a);
  bfstream& operator>>(int8_t& a);
  bfstream& operator>>(uint8_t & a);
  bfstream& operator>>(int16_t& a);
  bfstream& operator>>(uint16_t& a);
  bfstream& operator>>(int32_t& a);
  bfstream& operator>>(uint32_t& a);
  bfstream& operator>>(int64_t& a);
  bfstream& operator>>(uint64_t& a);
  bfstream& operator>>(float& a);
  bfstream& operator>>(double& a);
  bfstream& operator>>(bin& a);
  bfstream& operator>>(char* a);
  bfstream& operator>>(std::string& a);
};

} //namespace itpp


#endif // #ifndef BINFILE_H