/*

*

* 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)

#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