text: /*
   *
   * Copyright (c) 1997
   * Christian Michelsen Research AS
   * Advanced Computing
   * Fantoftvegen 38, 5036 BERGEN, Norway
   * http://www.cmr.no
   *
   * Permission to use, copy, modify, distribute and sell this software
   * and its documentation for any purpose is hereby granted without fee,
   * provided that the above copyright notice appear in all copies and
   * that both that copyright notice and this permission notice appear
   * in supporting documentation.  Christian Michelsen Research AS makes no
   * representations about the suitability of this software for any
   * purpose.  It is provided "as is" without express or implied warranty.
   *
   */
  
  #ifndef ZSTREAM__H
  #define ZSTREAM__H
  
  /*
   * zstream.h - C++ interface to the 'zlib' general purpose compression library
   * $Id: zstream.h,v 1.1 2005/09/23 22:39:03 beng Exp $
   */
  
  #include <strstream.h>
  #include <string.h>
  #include <stdio.h>
  #include "zlib.h"
  
  #if defined(_WIN32)
  #   include <fcntl.h>
  #   include <io.h>
  #   define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
  #else
  #   define SET_BINARY_MODE(file)
  #endif
  
  class zstringlen {
  public:
      zstringlen(class izstream&);
      zstringlen(class ozstream&, const char*);
      size_t value() const { return val.word; }
  private:
      struct Val { unsigned char byte; size_t word; } val;
  };
  
  //  ----------------------------- izstream -----------------------------
  
  class izstream
  {
      public:
          izstream() : m_fp(0) {}
          izstream(FILE* fp) : m_fp(0) { open(fp); }
          izstream(const char* name) : m_fp(0) { open(name); }
          ~izstream() { close(); }
  
          /* Opens a gzip (.gz) file for reading.
           * open() can be used to read a file which is not in gzip format;
           * in this case read() will directly read from the file without
           * decompression. errno can be checked to distinguish two error
           * cases (if errno is zero, the zlib error is Z_MEM_ERROR).
           */
          void open(const char* name) {
              if (m_fp) close();
              m_fp = ::gzopen(name, "rb");
          }
  
          void open(FILE* fp) {
              SET_BINARY_MODE(fp);
              if (m_fp) close();
              m_fp = ::gzdopen(fileno(fp), "rb");
          }
  
          /* Flushes all pending input if necessary, closes the compressed file
           * and deallocates all the (de)compression state. The return value is
           * the zlib error number (see function error() below).
           */
          int close() {
              int r = ::gzclose(m_fp);
              m_fp = 0; return r;
          }
  
          /* Binary read the given number of bytes from the compressed file.
           */
          int read(void* buf, size_t len) {
              return ::gzread(m_fp, buf, len);
          }
  
          /* Returns the error message for the last error which occurred on the
           * given compressed file. errnum is set to zlib error number. If an
           * error occurred in the file system and not in the compression library,
           * errnum is set to Z_ERRNO and the application may consult errno
           * to get the exact error code.
           */
          const char* error(int* errnum) {
              return ::gzerror(m_fp, errnum);
          }
  
          gzFile fp() { return m_fp; }
  
      private:
          gzFile m_fp;
  };
  
  /*
   * Binary read the given (array of) object(s) from the compressed file.
   * If the input file was not in gzip format, read() copies the objects number
   * of bytes into the buffer.
   * returns the number of uncompressed bytes actually read
   * (0 for end of file, -1 for error).
   */
  template <class T, class Items>
  inline int read(izstream& zs, T* x, Items items) {
      return ::gzread(zs.fp(), x, items*sizeof(T));
  }
  
  /*
   * Binary input with the '>' operator.
   */
  template <class T>
  inline izstream& operator>(izstream& zs, T& x) {
      ::gzread(zs.fp(), &x, sizeof(T));
      return zs;
  }
  
  
  inline zstringlen::zstringlen(izstream& zs) {
      zs > val.byte;
      if (val.byte == 255) zs > val.word;
      else val.word = val.byte;
  }
  
  /*
   * Read length of string + the string with the '>' operator.
   */
  inline izstream& operator>(izstream& zs, char* x) {
      zstringlen len(zs);
      ::gzread(zs.fp(), x, len.value());
      x[len.value()] = '\0';
      return zs;
  }
  
  inline char* read_string(izstream& zs) {
      zstringlen len(zs);
      char* x = new char[len.value()+1];
      ::gzread(zs.fp(), x, len.value());
      x[len.value()] = '\0';
      return x;
  }
  
  // ----------------------------- ozstream -----------------------------
  
  class ozstream
  {
      public:
          ozstream() : m_fp(0), m_os(0) {
          }
          ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
              : m_fp(0), m_os(0) {
              open(fp, level);
          }
          ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
              : m_fp(0), m_os(0) {
              open(name, level);
          }
          ~ozstream() {
              close();
          }
  
          /* Opens a gzip (.gz) file for writing.
           * The compression level parameter should be in 0..9
           * errno can be checked to distinguish two error cases
           * (if errno is zero, the zlib error is Z_MEM_ERROR).
           */
          void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
              char mode[4] = "wb\0";
              if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
              if (m_fp) close();
              m_fp = ::gzopen(name, mode);
          }
  
          /* open from a FILE pointer.
           */
          void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
              SET_BINARY_MODE(fp);
              char mode[4] = "wb\0";
              if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
              if (m_fp) close();
              m_fp = ::gzdopen(fileno(fp), mode);
          }
  
          /* Flushes all pending output if necessary, closes the compressed file
           * and deallocates all the (de)compression state. The return value is
           * the zlib error number (see function error() below).
           */
          int close() {
              if (m_os) {
                  ::gzwrite(m_fp, m_os->str(), m_os->pcount());
                  delete[] m_os->str(); delete m_os; m_os = 0;
              }
              int r = ::gzclose(m_fp); m_fp = 0; return r;
          }
  
          /* Binary write the given number of bytes into the compressed file.
           */
          int write(const void* buf, size_t len) {
              return ::gzwrite(m_fp, (voidp) buf, len);
          }
  
          /* Flushes all pending output into the compressed file. The parameter
           * _flush is as in the deflate() function. The return value is the zlib
           * error number (see function gzerror below). flush() returns Z_OK if
           * the flush_ parameter is Z_FINISH and all output could be flushed.
           * flush() should be called only when strictly necessary because it can
           * degrade compression.
           */
          int flush(int _flush) {
              os_flush();
              return ::gzflush(m_fp, _flush);
          }
  
          /* Returns the error message for the last error which occurred on the
           * given compressed file. errnum is set to zlib error number. If an
           * error occurred in the file system and not in the compression library,
           * errnum is set to Z_ERRNO and the application may consult errno
           * to get the exact error code.
           */
          const char* error(int* errnum) {
              return ::gzerror(m_fp, errnum);
          }
  
          gzFile fp() { return m_fp; }
  
          ostream& os() {
              if (m_os == 0) m_os = new ostrstream;
              return *m_os;
          }
  
          void os_flush() {
              if (m_os && m_os->pcount()>0) {
                  ostrstream* oss = new ostrstream;
                  oss->fill(m_os->fill());
                  oss->flags(m_os->flags());
                  oss->precision(m_os->precision());
                  oss->width(m_os->width());
                  ::gzwrite(m_fp, m_os->str(), m_os->pcount());
                  delete[] m_os->str(); delete m_os; m_os = oss;
              }
          }
  
      private:
          gzFile m_fp;
          ostrstream* m_os;
  };
  
  /*
   * Binary write the given (array of) object(s) into the compressed file.
   * returns the number of uncompressed bytes actually written
   * (0 in case of error).
   */
  template <class T, class Items>
  inline int write(ozstream& zs, const T* x, Items items) {
      return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
  }
  
  /*
   * Binary output with the '<' operator.
   */
  template <class T>
  inline ozstream& operator<(ozstream& zs, const T& x) {
      ::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
      return zs;
  }
  
  inline zstringlen::zstringlen(ozstream& zs, const char* x) {
      val.byte = 255;  val.word = ::strlen(x);
      if (val.word < 255) zs < (val.byte = val.word);
      else zs < val;
  }
  
  /*
   * Write length of string + the string with the '<' operator.
   */
  inline ozstream& operator<(ozstream& zs, const char* x) {
      zstringlen len(zs, x);
      ::gzwrite(zs.fp(), (voidp) x, len.value());
      return zs;
  }
  
  #ifdef _MSC_VER
  inline ozstream& operator<(ozstream& zs, char* const& x) {
      return zs < (const char*) x;
  }
  #endif
  
  /*
   * Ascii write with the << operator;
   */
  template <class T>
  inline ostream& operator<<(ozstream& zs, const T& x) {
      zs.os_flush();
      return zs.os() << x;
  }
  
  #endif
  