---

more/io/binary_io.h

Go to the documentation of this file.

//  Copyright (C) 2000--2002  Petter Urkedal
//
//  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: binary_io.h,v 1.2 2002/09/01 12:01:36 petter_urkedal Exp $


//  Status: experimental


#include <string>
#include <iostream>

#ifndef MORE_BINARY_IO_H
#define MORE_BINARY_IO_H

namespace more {
namespace io {

  //  ---/  Sequential Streaming of Bits  /---

  /** \class bit_writer binary_io.h more/io/binary_io.h
   ** Utility class to write one bit at a time to a stream. */
  template< typename OutputStream >
    struct bit_writer {
        typedef OutputStream stream_type;
        typedef typename OutputStream::char_type char_type;
        bit_writer(stream_type& os_)
            : os(os_), bit(1 << 8*sizeof(char_type)), ch(0) {}
        ~bit_writer() {
            if (bit != (1 << 8*sizeof(char_type)))
                os.put(ch);
        }
        void put(int x) {
            if (bit == 1) {
                os.put(ch);
                bit = 1 << 8*sizeof(char_type);
                ch = 0;
            }
            bit >>= 1;
            if (x) ch |= bit;
        }
      private:
        stream_type& os;
        int bit;
        char_type ch;
    };

  /** \class bit_reader binary_io.h more/io/binary_io.h
   ** Utility class to read one bit at a time from a stream. */
  template< typename InputStream >
    struct bit_reader {
        typedef typename InputStream::char_type char_type;
        typedef InputStream stream_type;
        bit_reader(stream_type& is_) : is(is_), bit(1), ch(0) {}
        int get() {
            if (bit == 1) {
                ch = is.get();
                bit = 1 << 8*sizeof(char_type);
            }
            bit >>= 1;
            return (ch & bit)? 1 : 0;
        }
      private:
        stream_type& is;
        int bit;
        char_type ch;
    };


  //  ---/  Binary IO for Integers  /---

  //  These are used to write integral _numbers_ to a binary stream.
  //  Do not use these for raw data or bitmasks, as they pack the data
  //  assuming that small number occur more frequently than large.

  void binary_write(std::ostream& os, char x);
  void binary_read(std::istream& is, char& x);

  void binary_write(std::ostream& os, signed char x);
  void binary_write(std::ostream& os, unsigned char x);
  void binary_read(std::istream& is, signed char& x);
  void binary_read(std::istream& is, unsigned char& x);

  void binary_write(std::ostream& os, short x);
  void binary_write(std::ostream& os, unsigned short x);
  void binary_read(std::istream& is, short& x);
  void binary_read(std::istream& is, unsigned short& x);

  void binary_write(std::ostream& os, int x);
  void binary_write(std::ostream& os, unsigned int x);
  void binary_read(std::istream& is, int& x);
  void binary_read(std::istream& is, unsigned int& x);

  void binary_write(std::ostream& os, long x);
  void binary_write(std::ostream& os, unsigned long x);
  void binary_read(std::istream& is, long& x);
  void binary_read(std::istream& is, unsigned long& x);

#ifdef MORE_HAVE_LONG_LONG
  void binary_write(std::ostream& os, long long x);
  void binary_write(std::ostream& os, unsigned long long x);
  void binary_read(std::istream& is, long long& x);
  void binary_read(std::istream& is, unsigned long long& x);
#endif

  // bool

  inline void binary_write(std::ostream& os, bool x)
    { binary_write(os, x? 1 : 0); }
  inline void binary_read(std::istream& is, bool& x)
    { int i; binary_read(is, i); x = i; }

  // FP

  void binary_write(std::ostream& os, float const& x,
                    int prec = std::numeric_limits<float>::digits);
  void binary_write(std::ostream& os, double const& x,
                    int prec = std::numeric_limits<double>::digits);
  void binary_write(std::ostream& os, long double const& x,
                    int prec = std::numeric_limits<long double>::digits);
  void binary_read(std::istream& is, float& x);
  void binary_read(std::istream& is, double& x);
  void binary_read(std::istream& is, long double& x);

  // strings

  void binary_write(std::ostream&, std::string);
  void binary_read(std::istream&, std::string&);

  void binary_write_raw(std::ostream&, void const*, size_t);
  //  Read raw block of known size, checking the size:
  void binary_read_raw(std::istream&, void*, size_t);
  //  Read raw block of unknown size:
  size_t binary_read_raw_size(std::istream&);
  void binary_read_raw_data(std::istream&, void*, size_t);


  // Binary IO of floats

  typedef long double big_float;

  void binary_put_fp(std::ostream& os, big_float x, int prec);
  big_float binary_get_fp(std::istream& is);


  /*X Dump the rest of the binary encoded \a is to \a os. */
  void binary_dump(std::istream& is, std::ostream& os, bool print_values_p);

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

#endif

---