---

more/io/syncstream.h

Go to the documentation of this file.

//  Copyright (C) 2000--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)

//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.

//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: syncstream.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $



//  Here is a way to implement versioning in a sub-structure
//
//      void someclass::sync(more::syncstream& sio) {
//          int version = 1;
//          sio | version;
//          switch (version) {
//            case 0:
//              sio | a | c;
//              b = b_default;
//              break;
//            case 1:
//              sio | a | b | c;
//            break;
//          }
//     }

#ifndef MORE_SYNCSTREAM_H
#define MORE_SYNCSTREAM_H

#include <stdexcept>
#include <string>
#include <utility>
#include <iostream>
#include <fstream>
#include <more/io/binary_io.h>
#include <complex>

namespace more {
namespace io {

  using std::size_t;


  /** \class syncstream syncstream.h more/io/syncstream.h
   **
   ** A stream which provides both input and output using the same
   ** calls.  The data is binary encoded, but architecture
   ** independent.  */
  struct syncstream
  {
      enum openmode
      {
          in = 1,
          out = 2,
          test = 3
      };

    protected:
      syncstream(std::streambuf* buf);
      syncstream(std::streambuf* buf, std::ios_base::openmode mode_);
      void prolog(std::ios_base::openmode mode_);

    public:
      /** Use \a dig mantissa bits precision for writing floats.  This
          defaults to \c std::numeric_limits<double>::digits.  This is
          an upper limit.  When writing a floating point number of
          type \c T, the smaller of \c std::numeric_limits<T>::digits
          and \a dig is used. */
      void set_digits(int dig) { m_dig = dig; }

      /** Use \a dig10 decimal digits precision for writing floats. */
      void set_digits10(int dig10);

      /** Return the mantissa bits precision as set by \c set_digits. */
      int digits() { return m_dig; }

      /** Return \c digits() converted to decimal digits. */
      int digits10();

      /** Return true if this is an input stream. */
      bool is_input() { return m_mode & std::ios_base::in; }

      /** Return true if this is an output stream. */
      bool is_output() { return m_mode & std::ios_base::out; }

      /** Return true if no errors has occured. */
      bool good() { return m_ios.good(); }

      /** Return true if an error has occured. */
      bool fail() { return m_ios.fail(); }

      /** Return true if a file read error has occured. */
      bool bad()  { return m_ios.bad(); }

      /** Set the fail state of the stream. */
      void setstate(std::ios_base::iostate st) { m_ios.setstate(st); }

      /** Clear the fail state of the stream. */
      void clear() { m_ios.clear(); }

      /** Sync known size raw data.  This breaks the binary dump
       ** utility.  Be careful if architecture independence is
       ** needed. */
      void sync_raw_data(void* p, size_t n);

      /** Call \c x.sync(*this) and return \c *this. */
      template<typename T>
        syncstream& operator|(T& x) { x.sync(*this); return *this; }

      ///@{
      /** Sync \a x into or out of the stream and return \c *this. */
      syncstream& operator|(char& x) { sync(x); return *this; }
      syncstream& operator|(signed char& x) { sync(x); return *this; }
      syncstream& operator|(unsigned char& x) { sync(x); return *this; }
      syncstream& operator|(short& x) { sync(x); return *this; }
      syncstream& operator|(unsigned short& x) { sync(x); return *this; }
      syncstream& operator|(int& x) { sync(x); return *this; }
      syncstream& operator|(unsigned int& x) { sync(x); return *this; }
      syncstream& operator|(long& x) { sync(x); return *this; }
      syncstream& operator|(unsigned long& x) { sync(x); return *this; }
#ifdef MORE_HAVE_LONG_LONG
      syncstream& operator|(long long& x) { sync(x); return *this; }
      syncstream& operator|(unsigned long long& x) {sync(x);return*this;}
#endif

      syncstream& operator|(bool& x) { sync(x); return *this; }

      syncstream& operator|(float& x) { sync_fp(x); return *this; }
      syncstream& operator|(double& x) { sync_fp(x); return *this; }
      syncstream& operator|(long double& x) { sync_fp(x); return *this; }
      syncstream& operator|(std::complex<float>& x)
      { sync_cplx(x); return *this; }
      syncstream& operator|(std::complex<double>& x)
      { sync_cplx(x); return *this; }
      syncstream& operator|(std::complex<long double>& x)
      { sync_cplx(x); return *this; }

      syncstream& operator|(std::string& x) { sync(x); return *this; }
      template<typename T, typename U>
        syncstream& operator|(std::pair<T, U>& x)
        {
            *this | x.first | x.second;
            return *this;
        }
      ///@}

      syncstream& operator|(void (*f)(syncstream&)) { f(*this); return *this; }

      /// \internal
      int _version() const { return m_version; }

    private:
      std::iostream             m_ios;
      std::ios_base::openmode   m_mode;
      int                       m_dig;
      int                       m_version;

      template<typename T>
        void sync(T& x)
        {
            if (m_mode & std::ios_base::binary) {
                if (m_mode & std::ios_base::out)
                    binary_write(m_ios, x);
                if (m_mode & std::ios_base::in)
                    binary_read(m_ios, x);
            }
            else
                throw std::logic_error
                  ("syncstream: ascii mode not implemented");
        }

      template<typename T>
        void sync_fp(T& x)
        {
            if (m_mode & std::ios_base::binary) {
                if (m_mode & std::ios_base::out)
                    binary_write(m_ios, x,
                                 std::min(std::numeric_limits<T>
                                          ::digits, m_dig));
                if (m_mode & std::ios_base::in)
                    binary_read(m_ios, x);
            }
            else
                throw std::logic_error
                  ("syncstream: ascii mode not implemented");
        }

      template<typename T>
        void sync_cplx(std::complex<T>& x)
        {
            T re = x.real();
            T im = x.imag();
            *this | re | im;
            x = std::complex<T>(re, im);
        }
  };

  /** \class setdigits syncstream.h more/io/syncstream.h
   ** 
   ** IO manipulator to set the precision of floats written by \c
   ** syncstream. */
  struct setdigits {
      setdigits(int dig_) : m_dig(dig_) {}

      friend syncstream&
      operator|(syncstream& sync, setdigits x)
      {
          sync.set_digits(x.m_dig);
          return sync;
      }
    private:
      int m_dig;
  };

  /** \class setdigits10 syncstream.h more/io/syncstream.h
   **
   ** IO manipulator to set the precision of floats written by \c
   ** syncstream. */
  struct setdigits10
  {
      setdigits10(int dig_) : m_dig(dig_) {}

      friend syncstream&
      operator|(syncstream& sync, setdigits10 x)
      {
          sync.set_digits10(x.m_dig);
          return sync;
      }
    private:
      int m_dig;
  };

  /** \class fsyncstream syncstream.h more/io/syncstream.h
   **
   ** A file-based syncstream. */
  struct fsyncstream : syncstream
  {
      fsyncstream()
          : syncstream(&sb) {}

      fsyncstream(const char* name, std::ios_base::openmode mode)
          : syncstream(&sb)
      {
          this->open(name, mode);
      }

      fsyncstream(const char* name, syncstream::openmode mode)
          : syncstream(&sb)
      {
          if (mode & in) {
              open(name, std::ios_base::binary | std::ios_base::in);
              if (!good() && (mode & out))
                  open(name, std::ios_base::binary | std::ios_base::out);
          }
      }

      std::filebuf* rdbuf() { return &sb; }
      std::filebuf const* rdbuf() const { return &sb; }

      bool is_open() const { return rdbuf()->is_open(); }

      void open(const char* name, std::ios_base::openmode mode) {
          rdbuf()->open(name, mode);
          prolog(mode);
      }

      void close() {
          clear();
          if (!rdbuf()->close())
              setstate(std::ios_base::failbit);
      }

    private:
      std::filebuf sb;
  };

  /** \class ifsyncstream syncstream.h more/io/syncstream.h
   **
   ** A file-based syncstream which will be opened for input. */
  struct ifsyncstream : fsyncstream
  {
      /** Construct a stream which be opend later with \c open. */
      ifsyncstream() {}

      /** Construct a syncstream with input from the file named \a name. */
      ifsyncstream(const char* name,
                   std::ios_base::openmode mode
                   = std::ios_base::in | std::ios_base::binary)
          : fsyncstream(name, mode) {}

      /** Open the file named \a name for input and attach it to this
       ** stream. */
      void open(const char* name,
                std::ios_base::openmode mode
                = std::ios_base::in | std::ios_base::binary)
      {
          fsyncstream::open(name, mode);
      }
  };

  /** \class ofsyncstream syncstream.h more/io/syncstream.h
   **
   ** A file-based syncstream which will be opened for output. */
  struct ofsyncstream : fsyncstream
  {
      /** Construct a stream which be opend later with \c open. */
      ofsyncstream() {}

      /** Construct a syncstream with output to the file named \a name. */
      ofsyncstream(const char* name,
                   std::ios_base::openmode mode
                   = std::ios_base::out | std::ios_base::binary)
          : fsyncstream(name, mode) {}

      /** Open \a name for writing and set it as output for this
       ** \c syncstream. */
      void
      open(const char* name,
           std::ios_base::openmode mode
           = std::ios_base::out | std::ios_base::binary)
      {
          fsyncstream::open(name, mode);
      }
  };

  /** Skip \a i items of type \a T. */
  template<typename T>
    void sync_skip(syncstream& sio, int i = 1)
    {
        T x;
        while (i) {
            sio | x;
            --i;
        }
    }

  /** Sync an length iterator range of known length. */
  template<typename Iterator>
    void sync_range(syncstream& sio, Iterator first, Iterator last)
    {
        while (first != last) sio | *first, ++first;
    }

  /** Sync a sequence (like a <tt>std::list</tt> or a
      <tt>std::vector</tt>). */
  template<typename Seq>
    void sync_sequence(syncstream& sio, Seq& c)
    {
        typename Seq::size_type n;
        if (sio.is_input()) {
            sio | n;
            if (!sio.good()) return;
            c.resize(n);
        }
        else {
            n = c.size();
            sio | n;
            if (!sio.good()) return;
        }
        sync_range(sio, c.begin(), c.end());
    }

  /** Sync an associative container (like a <tt>std::set</tt>).  */
  template<typename Assoc>
    void sync_associative_container(syncstream& sio, Assoc& x)
    {
        typename Assoc::size_type n;
        typename Assoc::value_type v;
        if (sio.is_input()) {
            sio | n;
            while (n--) {
                sio | v;
                x.insert(x.end(), v);
            }
        }
        else {
            n = x.size();
            sio | n;
            for (typename Assoc::iterator it = x.begin();
                 it != x.end(); ++it) {
                v = *it;
                sio | v;
            }
        }
    }

  /** Sync a pair-associative container (like a <tt>std::map</tt>). */
  template<typename Assoc>
    void sync_pair_associative_container(syncstream& sio, Assoc& x)
    {
        typename Assoc::size_type n;
        typename Assoc::key_type k;
        typename Assoc::data_type d;
        if (sio.is_input()) {
            sio | n;
            while (n--) {
                sio | k | d;
                x.insert(typename Assoc::value_type(k, d));
            }
        }
        else {
            n = x.size();
            sio | n;
            for (typename Assoc::iterator it = x.begin(); it != x.end();
                 ++it) {
                k = it->first;
                d = it->second;
                sio | k | d;
            }
        }
    }

}
#if defined(MORE_BACKWARD) && MORE_BACKWARD < 20010615
using namespace io;
#endif
}

#endif

---