/*

* A C++ I/O streams interface to the zlib gz* functions

*

* by Ludwig Schwardt <schwardt@sun.ac.za>

* original version by Kevin Ruland <kevin@rodin.wustl.edu>

*

* This version is standard-compliant and compatible with gcc 3.x.

*/

#ifndef ZFSTREAM_H

#define ZFSTREAM_H

#include <istream> // not iostream, since we don't need cin/cout

#include <ostream>

#include "zlib.h"

/*****************************************************************************/

/**

* @brief Gzipped file stream buffer class.

*

* This class implements basic_filebuf for gzipped files. It doesn't yet support

* seeking (allowed by zlib but slow/limited), putback and read/write access

* (tricky). Otherwise, it attempts to be a drop-in replacement for the standard

* file streambuf.

*/

class gzfilebuf : public std::streambuf

{

public:

// Default constructor.

gzfilebuf();

// Destructor.

virtual

~gzfilebuf();

/**

* @brief Set compression level and strategy on the fly.

* @param comp_level Compression level (see zlib.h for allowed values)

* @param comp_strategy Compression strategy (see zlib.h for allowed values)

* @return Z_OK on success, Z_STREAM_ERROR otherwise.

*

* Unfortunately, these parameters cannot be modified separately, as the

* previous zfstream version assumed. Since the strategy is seldom changed,

* it can default and setcompression(level) then becomes like the old

* setcompressionlevel(level).

*/

int

setcompression(int comp_level,

int comp_strategy = Z_DEFAULT_STRATEGY);

/**

* @brief Check if file is open.

* @return True if file is open.

*/

bool

is_open() const { return (file != NULL); }

/**

* @brief Open gzipped file.

* @param name File name.

* @param mode Open mode flags.

* @return @c this on success, NULL on failure.

*/

gzfilebuf*

open(const char* name,

std::ios_base::openmode mode);

/**

* @brief Attach to already open gzipped file.

* @param fd File descriptor.

* @param mode Open mode flags.

* @return @c this on success, NULL on failure.

*/

gzfilebuf*

attach(int fd,

std::ios_base::openmode mode);

/**

* @brief Close gzipped file.

* @return @c this on success, NULL on failure.

*/

gzfilebuf*

close();

protected:

/**

* @brief Convert ios open mode int to mode string used by zlib.

* @return True if valid mode flag combination.

*/

bool

open_mode(std::ios_base::openmode mode,

char* c_mode) const;

/**

* @brief Number of characters available in stream buffer.

* @return Number of characters.

*

* This indicates number of characters in get area of stream buffer.

* These characters can be read without accessing the gzipped file.

*/

virtual std::streamsize

showmanyc();

/**

* @brief Fill get area from gzipped file.

* @return First character in get area on success, EOF on error.

*

* This actually reads characters from gzipped file to stream

* buffer. Always buffered.

*/

virtual int_type

underflow();

/**

* @brief Write put area to gzipped file.

* @param c Extra character to add to buffer contents.

* @return Non-EOF on success, EOF on error.

*

* This actually writes characters in stream buffer to

* gzipped file. With unbuffered output this is done one

* character at a time.

*/

virtual int_type

overflow(int_type c = traits_type::eof());

/**

* @brief Installs external stream buffer.

* @param p Pointer to char buffer.

* @param n Size of external buffer.

* @return @c this on success, NULL on failure.

*

* Call setbuf(0,0) to enable unbuffered output.

*/

virtual std::streambuf*

setbuf(char_type* p,

std::streamsize n);

/**

* @brief Flush stream buffer to file.

* @return 0 on success, -1 on error.

*

* This calls underflow(EOF) to do the job.

*/

virtual int

sync();

//

// Some future enhancements

//

// virtual int_type uflow();

// virtual int_type pbackfail(int_type c = traits_type::eof());

// virtual pos_type

// seekoff(off_type off,

// std::ios_base::seekdir way,

// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);

// virtual pos_type

// seekpos(pos_type sp,

// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);

private:

/**

* @brief Allocate internal buffer.

*

* This function is safe to call multiple times. It will ensure

* that a proper internal buffer exists if it is required. If the

* buffer already exists or is external, the buffer pointers will be

* reset to their original state.

*/

void

enable_buffer();

/**

* @brief Destroy internal buffer.

*

* This function is safe to call multiple times. It will ensure

* that the internal buffer is deallocated if it exists. In any

* case, it will also reset the buffer pointers.

*/

void

disable_buffer();

/**

* Underlying file pointer.

*/

gzFile file;

/**

* Mode in which file was opened.

*/

std::ios_base::openmode io_mode;

/**

* @brief True if this object owns file descriptor.

*

* This makes the class responsible for closing the file

* upon destruction.

*/

bool own_fd;

/**

* @brief Stream buffer.

*

* For simplicity this remains allocated on the free store for the

* entire life span of the gzfilebuf object, unless replaced by setbuf.

*/

char_type* buffer;

/**

* @brief Stream buffer size.

*

* Defaults to system default buffer size (typically 8192 bytes).

* Modified by setbuf.

*/

std::streamsize buffer_size;

/**

* @brief True if this object owns stream buffer.

*

* This makes the class responsible for deleting the buffer

* upon destruction.

*/

bool own_buffer;

};

/*****************************************************************************/

/**

* @brief Gzipped file input stream class.

*

* This class implements ifstream for gzipped files. Seeking and putback

* is not supported yet.

*/

class gzifstream : public std::istream

{

public:

// Default constructor

gzifstream();

/**

* @brief Construct stream on gzipped file to be opened.

* @param name File name.

* @param mode Open mode flags (forced to contain ios::in).

*/

explicit

gzifstream(const char* name,

std::ios_base::openmode mode = std::ios_base::in);

/**

* @brief Construct stream on already open gzipped file.

* @param fd File descriptor.

* @param mode Open mode flags (forced to contain ios::in).

*/

explicit

gzifstream(int fd,

std::ios_base::openmode mode = std::ios_base::in);

/**

* Obtain underlying stream buffer.

*/

gzfilebuf*

rdbuf() const

{ return const_cast<gzfilebuf*>(&sb); }

/**

* @brief Check if file is open.

* @return True if file is open.

*/

bool

is_open() { return sb.is_open(); }

/**

* @brief Open gzipped file.

* @param name File name.

* @param mode Open mode flags (forced to contain ios::in).

*

* Stream will be in state good() if file opens successfully;

* otherwise in state fail(). This differs from the behavior of

* ifstream, which never sets the state to good() and therefore

* won't allow you to reuse the stream for a second file unless

* you manually clear() the state. The choice is a matter of

* convenience.

*/

void

open(const char* name,

std::ios_base::openmode mode = std::ios_base::in);

/**

* @brief Attach to already open gzipped file.

* @param fd File descriptor.

* @param mode Open mode flags (forced to contain ios::in).

*

* Stream will be in state good() if attach succeeded; otherwise

* in state fail().

*/

void

attach(int fd,

std::ios_base::openmode mode = std::ios_base::in);

/**

* @brief Close gzipped file.

*

* Stream will be in state fail() if close failed.

*/

void

close();

private:

/**

* Underlying stream buffer.

*/

gzfilebuf sb;

};

/*****************************************************************************/

/**

* @brief Gzipped file output stream class.

*

* This class implements ofstream for gzipped files. Seeking and putback

* is not supported yet.

*/

class gzofstream : public std::ostream

{

public:

// Default constructor

gzofstream();

/**

* @brief Construct stream on gzipped file to be opened.

* @param name File name.

* @param mode Open mode flags (forced to contain ios::out).

*/

explicit

gzofstream(const char* name,

std::ios_base::openmode mode = std::ios_base::out);

/**

* @brief Construct stream on already open gzipped file.

* @param fd File descriptor.

* @param mode Open mode flags (forced to contain ios::out).

*/

explicit

gzofstream(int fd,

std::ios_base::openmode mode = std::ios_base::out);

/**

* Obtain underlying stream buffer.

*/

gzfilebuf*

rdbuf() const

{ return const_cast<gzfilebuf*>(&sb); }

/**

* @brief Check if file is open.

* @return True if file is open.

*/

bool

is_open() { return sb.is_open(); }

/**

* @brief Open gzipped file.

* @param name File name.

* @param mode Open mode flags (forced to contain ios::out).

*

* Stream will be in state good() if file opens successfully;

* otherwise in state fail(). This differs from the behavior of

* ofstream, which never sets the state to good() and therefore

* won't allow you to reuse the stream for a second file unless

* you manually clear() the state. The choice is a matter of

* convenience.

*/

void

open(const char* name,

std::ios_base::openmode mode = std::ios_base::out);

/**

* @brief Attach to already open gzipped file.

* @param fd File descriptor.

* @param mode Open mode flags (forced to contain ios::out).

*

* Stream will be in state good() if attach succeeded; otherwise

* in state fail().

*/

void

attach(int fd,

std::ios_base::openmode mode = std::ios_base::out);

/**

* @brief Close gzipped file.

*

* Stream will be in state fail() if close failed.

*/

void

close();

private:

/**

* Underlying stream buffer.

*/

gzfilebuf sb;

};

/*****************************************************************************/

/**

* @brief Gzipped file output stream manipulator class.

*

* This class defines a two-argument manipulator for gzofstream. It is used

* as base for the setcompression(int,int) manipulator.

*/

template<typename T1, typename T2>

class gzomanip2

{

public:

// Allows insertor to peek at internals

template <typename Ta, typename Tb>

friend gzofstream&

operator<<(gzofstream&,

const gzomanip2<Ta,Tb>&);

// Constructor

gzomanip2(gzofstream& (*f)(gzofstream&, T1, T2),

T1 v1,

T2 v2);

private:

// Underlying manipulator function

gzofstream&

(*func)(gzofstream&, T1, T2);

// Arguments for manipulator function

T1 val1;

T2 val2;

};

/*****************************************************************************/

// Manipulator function thunks through to stream buffer

inline gzofstream&

setcompression(gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY)

{

(gzs.rdbuf())->setcompression(l, s);

return gzs;

}

// Manipulator constructor stores arguments

template<typename T1, typename T2>

inline

gzomanip2<T1,T2>::gzomanip2(gzofstream &(*f)(gzofstream &, T1, T2),

T1 v1,

T2 v2)

: func(f), val1(v1), val2(v2)

{ }

// Insertor applies underlying manipulator function to stream

template<typename T1, typename T2>

inline gzofstream&

operator<<(gzofstream& s, const gzomanip2<T1,T2>& m)

{ return (*m.func)(s, m.val1, m.val2); }

// Insert this onto stream to simplify setting of compression level

inline gzomanip2<int,int>

setcompression(int l, int s = Z_DEFAULT_STRATEGY)

{ return gzomanip2<int,int>(&setcompression, l, s); }

#endif // ZFSTREAM_H