/* * * 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 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $ */#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)#endifclass 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_VERinline 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