qdp_io.h

Go to the documentation of this file.

// -*- C++ -*-

 
#ifndef QDP_IO_H
#define QDP_IO_H
 
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include "qdp_byteorder.h"
#include <vector>
#include <map>
#include <list>
 
#if 1
#include <complex>
#endif
 
namespace QDP
{
 
  //--------------------------------------------------------------------------------

 
  class TextReader
  {
  public:
    TextReader();

    virtual ~TextReader() {}


    virtual bool fail();
 
    // Readers for builtin types
    virtual void read(std::string& result);
    virtual void read(char& result);
    virtual void read(int& result);
    virtual void read(unsigned int& result);
    virtual void read(short int& result);
    virtual void read(unsigned short int& result);
    virtual void read(long int& result);
    virtual void read(unsigned long int& result);
    virtual void read(long long int& result);
    virtual void read(float& result);
    virtual void read(double& result);
    virtual void read(bool& result);
 
  protected:

    template< typename T>
    void
    readPrimitive(T& output);

    virtual std::istream& getIstream() = 0;
  };
 
 
  // Different bindings for same operators
  TextReader& operator>>(TextReader& txt, std::string& input);
  TextReader& operator>>(TextReader& txt, char& input);
  TextReader& operator>>(TextReader& txt, int& input);
  TextReader& operator>>(TextReader& txt, unsigned int& input);
  TextReader& operator>>(TextReader& txt, short int& input);
  TextReader& operator>>(TextReader& txt, unsigned short int& input);
  TextReader& operator>>(TextReader& txt, long int& input);
  TextReader& operator>>(TextReader& txt, unsigned long int& input);
  TextReader& operator>>(TextReader& txt, long long int& input);
  TextReader& operator>>(TextReader& txt, float& input);
  TextReader& operator>>(TextReader& txt, double& input);
  TextReader& operator>>(TextReader& txt, bool& input);
 
 
  //--------------------------------------------------------------------------------

 
  class TextBufferReader : public TextReader
  {
  public:
    TextBufferReader();

    ~TextBufferReader(); 

    explicit TextBufferReader(const std::string& p);


    void open(const std::string& p);

    std::string str() const;
        
    std::string strPrimaryNode() const;
        
  protected:
    std::istream& getIstream() {return f;}
 
  private:
    std::istringstream f;
  };
 
 
  //--------------------------------------------------------------------------------

 
  class TextFileReader : public TextReader
  {
  public:
    TextFileReader();

    ~TextFileReader(); 

    explicit TextFileReader(const std::string& p);


    void open(const std::string& p);

    void close();


    bool is_open();
 
  protected:
    std::istream& getIstream() {return f;}
 
  private:
    std::ifstream f;
  };
 
 
  //--------------------------------------------------------------------------------

  class TextWriter
  {
  public:
    TextWriter();

    virtual ~TextWriter() {}

    virtual void flush() = 0;


    virtual bool fail();
    
    // Overloaded Writer Functions
    virtual void write(const std::string& output);
    virtual void write(const char* output);
    virtual void write(const char& output);
    virtual void write(const int& output);
    virtual void write(const unsigned int& output);
    virtual void write(const short int& output);
    virtual void write(const unsigned short int& output);
    virtual void write(const long int& output);
    virtual void write(const unsigned long int& output);
    virtual void write(const long long int& output);
    virtual void write(const float& output);
    virtual void write(const double& output);
    virtual void write(const bool& output);
 
  protected:

    template< typename T>
    void
    writePrimitive(const T& output);

    virtual std::ostream& getOstream() = 0;
  };
 
 
  // Different bindings for same operators
  TextWriter& operator<<(TextWriter& txt, const std::string& output);
  TextWriter& operator<<(TextWriter& txt, const char* output);
  TextWriter& operator<<(TextWriter& txt, char output);
  TextWriter& operator<<(TextWriter& txt, int output);
  TextWriter& operator<<(TextWriter& txt, unsigned int output);
  TextWriter& operator<<(TextWriter& txt, short int output);
  TextWriter& operator<<(TextWriter& txt, unsigned short int output);
  TextWriter& operator<<(TextWriter& txt, long int output);
  TextWriter& operator<<(TextWriter& txt, unsigned long int output);
  TextWriter& operator<<(TextWriter& txt, long long int output);
  TextWriter& operator<<(TextWriter& txt, float output);
  TextWriter& operator<<(TextWriter& txt, double output);
  TextWriter& operator<<(TextWriter& txt, bool output);
 
 
  //--------------------------------------------------------------------------------

  class TextBufferWriter : public TextWriter
  {
  public:
    TextBufferWriter();

    ~TextBufferWriter();

    explicit TextBufferWriter(const std::string& p);

    void open(const std::string& s);

    void flush() {}

    std::string str() const;
        
    std::string strPrimaryNode() const;
        
  protected:
    std::ostream& getOstream() {return f;}
 
  private:
    std::ostringstream f;
  };
 
 
  //--------------------------------------------------------------------------------

  class TextFileWriter : public TextWriter
  {
  public:
    TextFileWriter();

    ~TextFileWriter();

    explicit TextFileWriter(const std::string& p);


    bool is_open();

    void open(const std::string& p);

    void close();

    void flush();
 
  protected:
    std::ostream& getOstream() {return f;}
 
  private:
    std::ofstream f;
  };
 
 
  //--------------------------------------------------------------------------------

  class BinaryReader
  {
  public:
    typedef std::istream::pos_type pos_type;  // position in buffer
    typedef std::istream::off_type off_type;  // offset in buffer
 
  public:
    virtual ~BinaryReader() {}


    virtual void readArrayPrimaryNode(char* output, size_t nbytes, size_t nmemb);


    virtual void readArray(char* output, size_t nbytes, size_t nmemb);


    virtual void readArrayLittleEndian(char* output, size_t nbytes, size_t nmemb);
 
    virtual void readArrayPrimaryNodeLittleEndian(char* output, size_t nbytes, size_t nmemb);
 
    // Overloaded reader functions
    virtual void readDesc(std::string& result);


    virtual void read(std::string& result, size_t nbytes);
 
    virtual void read(char& result);
    virtual void read(int& result);
    virtual void read(unsigned int& result);
    virtual void read(short int& result);
    virtual void read(unsigned short int& result);
    virtual void read(long int& result);
    virtual void read(unsigned long int& result);
    virtual void read(long long int& result);
    virtual void read(float& result);
    virtual void read(double& result);
    virtual void read(bool& result);


    virtual bool fail();

    virtual QDPUtil::n_uint32_t getChecksum();
  
    virtual void resetChecksum();
  
    virtual pos_type currentPosition();


    virtual void seek(pos_type off);


    virtual void seekBegin(off_type off);


    virtual void seekRelative(off_type off);


    virtual void seekEnd(off_type off);


    virtual void rewind();
 
  protected:

    template< typename T>
    void
    readPrimitive(T& output);

    virtual QDPUtil::n_uint32_t& internalChecksum() = 0;
  
    virtual std::istream& getIstream() = 0;
  };
 
 
  // Telephone book of basic primitives
  void readDesc(BinaryReader& bin, std::string& input);
  void read(BinaryReader& bin, std::string& input, size_t maxBytes);
  void read(BinaryReader& bin, char& input);
  void read(BinaryReader& bin, int& input);
  void read(BinaryReader& bin, unsigned int& input);
  void read(BinaryReader& bin, short int& input);
  void read(BinaryReader& bin, unsigned short int& input);
  void read(BinaryReader& bin, long int& input);
  void read(BinaryReader& bin, unsigned long int& input);
  void read(BinaryReader& bin, long long int& input);
  void read(BinaryReader& bin, float& input);
  void read(BinaryReader& bin, double& input);
  void read(BinaryReader& bin, bool& input);
 
  // Different bindings for same operators
  BinaryReader& operator>>(BinaryReader& bin, char& input);
  BinaryReader& operator>>(BinaryReader& bin, int& input);
  BinaryReader& operator>>(BinaryReader& bin, unsigned int& input);
  BinaryReader& operator>>(BinaryReader& bin, short int& input);
  BinaryReader& operator>>(BinaryReader& bin, unsigned short int& input);
  BinaryReader& operator>>(BinaryReader& bin, long int& input);
  BinaryReader& operator>>(BinaryReader& bin, unsigned long int& input);
  BinaryReader& operator>>(BinaryReader& bin, long long int& input);
  BinaryReader& operator>>(BinaryReader& bin, float& input);
  BinaryReader& operator>>(BinaryReader& bin, double& input);
  BinaryReader& operator>>(BinaryReader& bin, bool& input);
 
#if 1
  void read(BinaryReader& bin, std::complex<float>& param);
  void read(BinaryReader& bin, std::complex<double>& param);
#endif
 


  template<class T>
  inline
  void read(BinaryReader& bin, multi1d<T>& d)
  {
    int n;
    read(bin, n);    // the size is always written, even if 0
    d.resize(n);
 
    for(int i=0; i < d.size(); ++i)
      read(bin, d[i]);
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, multi1d<T>& d, int num)
  {
    for(int i=0; i < num; ++i)
      read(bin, d[i]);
  }


  template<class T>
  inline
  void read(BinaryReader& bin, multi2d<T>& d, int num1, int num2)
  {
    for(int i=0; i < num2; ++i)
      for(int j=0; j < num1; ++j)
        read(bin, d[j][i]);
 
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, multi2d<T>& d)
  {
    int n1;
    int n2;
    read(bin, n1);    // the size is always written, even if 0
    read(bin, n2);    // the size is always written, even if 0
    d.resize(n1,n2);
  
    for(int i=0; i < d.size1(); ++i)
      for(int j=0; j < d.size2(); ++j)
      {
        read(bin, d[j][i]);
      }
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, multi3d<T>& d)
  {
    int n1;
    int n2;
    int n3;
    read(bin, n3);    // the size is always written, even if 0
    read(bin, n2);    // the size is always written, even if 0
    read(bin, n1);    // the size is always written, even if 0
 
    // Destructively resize the array
    d.resize(n3,n2,n1);
 
    for(int i=0; i < d.size1(); ++i)
    {
      for(int j=0; j < d.size2(); ++j)
      {
        for(int k=0; k < d.size3(); ++k)
        {
          read(bin, d[k][j][i]);
        }
      }
    }
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, multi4d<T>& d)
  {
    int n1;
    int n2;
    int n3;
    int n4;
    read(bin, n4);    // the size is always written, even if 0
    read(bin, n3);    // the size is always written, even if 0
    read(bin, n2);    // the size is always written, even if 0
    read(bin, n1);    // the size is always written, even if 0
 
    // Destructively resize the array
    d.resize(n4,n3,n2,n1);
 
    for(int i=0; i < d.size1(); ++i)
    {
      for(int j=0; j < d.size2(); ++j)
      {
        for(int k=0; k < d.size3(); ++k)
        {
          for(int l=0; l < d.size4(); ++l)
          {
            read(bin, d[l][k][j][i]);
          }
        }
      }
    }
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, multi5d<T>& d)
  {
    int n1;
    int n2;
    int n3;
    int n4;
    int n5;
    read(bin, n5);    // the size is always written, even if 0
    read(bin, n4);    // the size is always written, even if 0
    read(bin, n3);    // the size is always written, even if 0
    read(bin, n2);    // the size is always written, even if 0
    read(bin, n1);    // the size is always written, even if 0
 
    // Destructively resize the array
    d.resize(n5,n4,n3,n2,n1);
 
    for(int i=0; i < d.size1(); ++i)
    {
      for(int j=0; j < d.size2(); ++j)
      {
        for(int k=0; k < d.size3(); ++k)
        {
          for(int l=0; l < d.size4(); ++l)
          {
            for(int m=0; m < d.size5(); ++m)
            {
              read(bin, d[m][l][k][j][i]);
            }
          }
        }
      }
    }
  }
 

  template<class T>
  inline
  void read(BinaryReader& bin, multiNd<T>& d)
  {
    multi1d<int> siz;
    read(bin, siz); // read the array of the sizes
 
    d.resize(siz);
 
    for(int i=0; i < d.numElem(); ++i)
      read(bin, d.getElem(i));
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, std::vector<T>& d)
  {
    int n;
    read(bin, n);    // the size is always written, even if 0
    d.resize(n);
 
    for(int i=0; i < d.size(); ++i)
      read(bin, d[i]);
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, std::list<T>& d)
  {
    d.clear();
 
    int n;
    read(bin, n);    // the size is always written, even if 0
 
    for(int i=0; i < n; ++i)
    {
      T thingy;
      read(bin, thingy);
 
      d.push_back(thingy);
    }
  }
 


  template<class T>
  inline
  void read(BinaryReader& bin, Array1dO<T>& d)
  {
    int n;
    read(bin, n);    // the size is always written, even if 0
    d.resize(n);
 
    for(int i=1; i <= d.size(); ++i)
      read(bin, d[i]);
  }
 


  template<typename K, typename V>
  inline
  void read(BinaryReader& bin, std::map<K,V>& d)
  {
    d.clear();
 
    int n;
    read(bin, n);    // the size is always written, even if 0
 
    for(int i=0; i < n; ++i)
    {
      K key;
      read(bin, key);
 
      V val;
      read(bin, val);
 
      d.insert(std::make_pair(key,val));
    }
  }
 


  template<typename T1, typename T2>
  inline
  void read(BinaryReader& bin, std::pair<T1,T2>& d)
  {
    T1 f;
    read(bin, f);
 
    T2 s;
    read(bin, s);
 
    d = std::make_pair(f,s);
  }
 
 
  //--------------------------------------------------------------------------------

  class BinaryBufferReader : public BinaryReader
  {
  public:
    BinaryBufferReader();

    explicit BinaryBufferReader(const std::string& s);

    ~BinaryBufferReader();

    void open(const std::string& s);

    std::string str() const;
        
    std::string strPrimaryNode() const;
        
    void clear();
 
  protected:
    QDPUtil::n_uint32_t& internalChecksum() {return checksum;}
  
    std::istream& getIstream() {return f;}
 
  private:
    QDPUtil::n_uint32_t checksum;
    std::istringstream f;
  };
 
 
  //--------------------------------------------------------------------------------

  class BinaryFileReader : public BinaryReader
  {
  public:
    BinaryFileReader();

    ~BinaryFileReader();

    explicit BinaryFileReader(const std::string& p);


    bool is_open();


    void open(const std::string& p);

    void close();
 
  protected:
    QDPUtil::n_uint32_t& internalChecksum() {return checksum;}
  
    std::istream& getIstream() {return f;}
 
  private:
    QDPUtil::n_uint32_t checksum;
    std::ifstream f;
  };
 
 
  //--------------------------------------------------------------------------------

  class BinaryWriter
  {
  public:
    typedef std::ostream::pos_type pos_type;  // position in buffer
    typedef std::ostream::off_type off_type;  // offset in buffer
 
  public:
    BinaryWriter();

    virtual ~BinaryWriter() {}

    virtual void flush() = 0;


    virtual void writeArrayPrimaryNode(const char* output, size_t nbytes, size_t nmemb);


    virtual void writeArray(const char* output, size_t nbytes, size_t nmemb);
 
    // Overloaded Writer Functions

    virtual void writeDesc(const std::string& output);

    virtual void write(const std::string& output);
    virtual void write(const char* output);
    virtual void write(const char& output);
    virtual void write(const int& output);
    virtual void write(const unsigned int& output);
    virtual void write(const short int& output);
    virtual void write(const unsigned short int& output);
    virtual void write(const long int& output);
    virtual void write(const unsigned long int& output);
    virtual void write(const long long int& output);
    virtual void write(const float& output);
    virtual void write(const double& output);
    virtual void write(const bool& output);


    virtual bool fail();

    virtual QDPUtil::n_uint32_t getChecksum();
  
    virtual void resetChecksum();
  
    virtual pos_type currentPosition();


    virtual void seek(pos_type off);


    virtual void seekBegin(off_type off);


    virtual void seekRelative(off_type off);


    virtual void seekEnd(off_type off);


    virtual void rewind();
 
  protected:


    template< typename T>
    void
    writePrimitive(const T& output);

    virtual QDPUtil::n_uint32_t& internalChecksum() = 0;
  
    virtual std::ostream& getOstream() = 0;
  };
 
 
  // Telephone book of basic primitives
  void writeDesc(BinaryWriter& bin, const std::string& output);
  void write(BinaryWriter& bin, const std::string& output);
  void write(BinaryWriter& bin, const char* output);
  void write(BinaryWriter& bin, char output);
  void write(BinaryWriter& bin, int output);
  void write(BinaryWriter& bin, unsigned int output);
  void write(BinaryWriter& bin, short int output);
  void write(BinaryWriter& bin, unsigned short int output);
  void write(BinaryWriter& bin, long int output);
  void write(BinaryWriter& bin, unsigned long int output);
  void write(BinaryWriter& bin, long long int output);
  void write(BinaryWriter& bin, float output);
  void write(BinaryWriter& bin, double output);
  void write(BinaryWriter& bin, bool output);
 
  // Different bindings for same operators
  BinaryWriter& operator<<(BinaryWriter& bin, const std::string& output);
  BinaryWriter& operator<<(BinaryWriter& bin, const char* output);
  BinaryWriter& operator<<(BinaryWriter& bin, char output);
  BinaryWriter& operator<<(BinaryWriter& bin, int output);
  BinaryWriter& operator<<(BinaryWriter& bin, unsigned int output);
  BinaryWriter& operator<<(BinaryWriter& bin, short int output);
  BinaryWriter& operator<<(BinaryWriter& bin, unsigned short int output);
  BinaryWriter& operator<<(BinaryWriter& bin, long int output);
  BinaryWriter& operator<<(BinaryWriter& bin, unsigned long int output);
  BinaryWriter& operator<<(BinaryWriter& bin, long long int output);
  BinaryWriter& operator<<(BinaryWriter& bin, float output);
  BinaryWriter& operator<<(BinaryWriter& bin, double output);
  BinaryWriter& operator<<(BinaryWriter& bin, bool output);
 
#if 1
  void write(BinaryWriter& bin, const std::complex<float>& param);
  void write(BinaryWriter& bin, const std::complex<double>& param);
#endif


  template<class T>
  inline
  void write(BinaryWriter& bin, const multi1d<T>& d)
  {
    write(bin, d.size());    // always write the size
    for(int i=0; i < d.size(); ++i)
      write(bin, d[i]);
  }


  template<class T>
  inline
  void write(BinaryWriter& bin, const multi1d<T>& d, int num)
  {
    for(int i=0; i < num; ++i)
      write(bin, d[i]);
  }
 

  template<class T>
  inline
  void write(BinaryWriter& bin, const multi2d<T>& d)
  {
    write(bin, d.size2());    // always write the size
    write(bin, d.size1());    // always write the size
 
    for(int i=0; i < d.size1(); ++i)
      for(int j=0; j < d.size2(); ++j)
      {
        write(bin, d[j][i]);
      }
 
  }
 
 

  template<class T>
  inline
  void write(BinaryWriter& bin, const multi3d<T>& d)
  {
    write(bin, d.size3());    // always write the size
    write(bin, d.size2());    // always write the size
    write(bin, d.size1());    // always write the size
 
    for(int i=0; i < d.size1(); ++i)
      for(int j=0; j < d.size2(); ++j)
        for(int k=0; k < d.size3(); ++k)
          write(bin, d[k][j][i]);
   }
 

  template<class T>
  inline
  void write(BinaryWriter& bin, const multi4d<T>& d)
  {
    write(bin, d.size4());    // always write the size
    write(bin, d.size3());    // always write the size
    write(bin, d.size2());    // always write the size
    write(bin, d.size1());    // always write the size
 
    for(int i=0; i < d.size1(); ++i)
      for(int j=0; j < d.size2(); ++j)
        for(int k=0; k < d.size3(); ++k)
          for(int l=0; l < d.size4(); ++l)
            write(bin, d[l][k][j][i]);
   }
 

  template<class T>
  inline
  void write(BinaryWriter& bin, const multi5d<T>& d)
  {
    write(bin, d.size5());    // always write the size
    write(bin, d.size4());    // always write the size
    write(bin, d.size3());    // always write the size
    write(bin, d.size2());    // always write the size
    write(bin, d.size1());    // always write the size
 
    for(int i=0; i < d.size1(); ++i)
      for(int j=0; j < d.size2(); ++j)
        for(int k=0; k < d.size3(); ++k)
          for(int l=0; l < d.size4(); ++l)
            for(int m=0; m < d.size5(); ++m)
              write(bin, d[m][l][k][j][i]);
   }
 

  template<class T>
  inline
  void write(BinaryWriter& bin, const multiNd<T>& d)
  {
    write(bin, d.size()); // write the array of the sizes
 
    for(int i=0; i < d.numElem(); ++i)
      write(bin, d.getElem(i));
  }
 


  template<class T>
  inline
  void write(BinaryWriter& bin, const std::vector<T>& d)
  {
    int n = d.size();
    write(bin, n);    // always write the size
    for(int i=0; i < d.size(); ++i)
      write(bin, d[i]);
  }
 


  template<class T>
  inline
  void write(BinaryWriter& bin, const std::list<T>& d)
  {
    int n = d.size();
    write(bin, n);    // always write the size
    for(typename std::list<T>::const_iterator p = d.begin(); p != d.end(); ++p)
      write(bin, *p);
  }
 


  template<class T>
  inline
  void write(BinaryWriter& bin, const Array1dO<T>& d)
  {
    int n = d.size();
    write(bin, n);    // always write the size
    for(int i=1; i <= d.size(); ++i)
      write(bin, d[i]);
  }
 


  template<typename K, typename V>
  inline
  void write(BinaryWriter& bin, const std::map<K,V>& d)
  {
    int n = d.size();
    write(bin, n);    // always write the size
 
    for(typename std::map<K,V>::const_iterator v = d.begin();
        v != d.end();
        ++v)
    {
      write(bin, v->first);
      write(bin, v->second);
    }
  }
 


  template<typename T1, typename T2>
  inline
  void write(BinaryWriter& bin, const std::pair<T1,T2>& d)
  {
    write(bin, d.first);
    write(bin, d.second);
  }
 
 
  //--------------------------------------------------------------------------------

  class BinaryBufferWriter : public BinaryWriter
  {
  public:
    BinaryBufferWriter();

    explicit BinaryBufferWriter(const std::string& s);

    ~BinaryBufferWriter();

    void open(const std::string& s);

    std::string str() const;
        
    std::string strPrimaryNode() const;
        
    void flush() {}

    void clear();
 
  protected:
    QDPUtil::n_uint32_t& internalChecksum() {return checksum;}
  
    std::ostream& getOstream() {return f;}
 
  private:
    QDPUtil::n_uint32_t checksum;
    std::ostringstream f;
  };
 
  //--------------------------------------------------------------------------------

  class BinaryFileWriter : public BinaryWriter
  {
  public:
    explicit BinaryFileWriter();

    ~BinaryFileWriter();

    explicit BinaryFileWriter(const std::string& p);


    bool is_open();
    
    void open(const std::string& p);

    void close();

    void flush();
 
  protected:
    QDPUtil::n_uint32_t& internalChecksum() {return checksum;}
  
    std::ostream& getOstream() {return f;}
 
  private:
    QDPUtil::n_uint32_t checksum;
    std::ofstream f;
  };
 
 
  //--------------------------------------------------------------------------------

  class BinaryReaderWriter : public BinaryReader, public BinaryWriter
  {
  public:
    typedef std::iostream::pos_type pos_type;  // position in buffer
    typedef std::iostream::off_type off_type;  // offset in buffer
 
  public:
    virtual ~BinaryReaderWriter() {}


    virtual bool fail();

    virtual QDPUtil::n_uint32_t getChecksum();
  
    virtual void resetChecksum();
  
    virtual pos_type currentPosition();


    virtual void seek(pos_type off);


    virtual void seekBegin(off_type off);


    virtual void seekRelative(off_type off);


    virtual void seekEnd(off_type off);


    virtual void rewind();
 
 
  protected:
    virtual QDPUtil::n_uint32_t& internalChecksum() = 0;
  
    virtual std::istream& getIstream() = 0;
  
    virtual std::ostream& getOstream() = 0;
  
    virtual std::iostream& getIOstream() = 0;
  };
 
 
  //--------------------------------------------------------------------------------

  class BinaryBufferReaderWriter : public BinaryReaderWriter
  {
  public:
    BinaryBufferReaderWriter();

    explicit BinaryBufferReaderWriter(const std::string& s);

    ~BinaryBufferReaderWriter();

    void open(const std::string& s);

    std::string str() const;
        
    std::string strPrimaryNode() const;
        
    void flush() {}

    void clear();
 
  protected:
    QDPUtil::n_uint32_t& internalChecksum() {return checksum;}
  
    std::istream& getIstream() {return f;}

    std::ostream& getOstream() {return f;}

    std::iostream& getIOstream() {return f;}
 
  private:
    QDPUtil::n_uint32_t checksum;
    std::stringstream f;
  };
 
 
  //--------------------------------------------------------------------------------

  class BinaryFileReaderWriter : public BinaryReaderWriter
  {
  public:
    BinaryFileReaderWriter();

    ~BinaryFileReaderWriter();

    explicit BinaryFileReaderWriter(const std::string& p, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);


    bool is_open();


    void open(const std::string& p, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out);

    void close();

    void flush();
 
  protected:
    QDPUtil::n_uint32_t& internalChecksum() {return checksum;}
  
    std::istream& getIstream() {return f;}

    std::ostream& getOstream() {return f;}

    std::iostream& getIOstream() {return f;}
 
  private:
    QDPUtil::n_uint32_t checksum;
    std::fstream f;
  };
 
   // end of group io
} // namespace QDP
 
#endif