gzfilebuf Class Reference

Gzipped file stream buffer class. More...

#include <zfstream.h>

Inheritance diagram for gzfilebuf:

Public Member Functions
	gzfilebuf ()
virtual	~gzfilebuf ()
gzfilebuf *	open (const char *name, int io_mode)
gzfilebuf *	attach (int file_descriptor, int io_mode)
gzfilebuf *	close ()
int	setcompressionlevel (int comp_level)
int	setcompressionstrategy (int comp_strategy)
int	is_open () const
virtual streampos	seekoff (streamoff, ios::seek_dir, int)
virtual int	sync ()
	gzfilebuf ()
virtual	~gzfilebuf ()
int	setcompression (int comp_level, int comp_strategy=Z_DEFAULT_STRATEGY)
	Set compression level and strategy on the fly. More...
bool	is_open () const
	Check if file is open. More...
gzfilebuf *	open (const char *name, std::ios_base::openmode mode)
	Open gzipped file. More...
gzfilebuf *	attach (int fd, std::ios_base::openmode mode)
	Attach to already open gzipped file. More...
gzfilebuf *	close ()
	Close gzipped file. More...

Protected Member Functions
virtual int	underflow ()
virtual int	overflow (int=EOF)
bool	open_mode (std::ios_base::openmode mode, char *c_mode) const
	Convert ios open mode int to mode string used by zlib. More...
virtual std::streamsize	showmanyc ()
	Number of characters available in stream buffer. More...
virtual int_type	underflow ()
	Fill get area from gzipped file. More...
virtual int_type	overflow (int_type c=traits_type::eof())
	Write put area to gzipped file. More...
virtual std::streambuf *	setbuf (char_type *p, std::streamsize n)
	Installs external stream buffer. More...
virtual int	sync ()
	Flush stream buffer to file. More...

Private Member Functions
int	flushbuf ()
int	fillbuf ()
void	enable_buffer ()
	Allocate internal buffer. More...
void	disable_buffer ()
	Destroy internal buffer. More...

Private Attributes
gzFile	file
short	mode
short	own_file_descriptor
std::ios_base::openmode	io_mode
bool	own_fd
	True if this object owns file descriptor. More...
char_type *	buffer
	Stream buffer. More...
std::streamsize	buffer_size
	Stream buffer size. More...
bool	own_buffer
	True if this object owns stream buffer. More...

Detailed Description

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.

Definition at line 8 of file zfstream.h.

Constructor & Destructor Documentation

gzfilebuf() [1/2]

gzfilebuf::gzfilebuf

(

)

Definition at line 4 of file zfstream.cpp.

                     :
  file(NULL),
  mode(0),
  own_file_descriptor(0)
{ }

~gzfilebuf() [1/2]

gzfilebuf::~gzfilebuf ( )

virtual

Definition at line 10 of file zfstream.cpp.

                      {
 
  sync();
  if ( own_file_descriptor )
    close();
 
}

References close(), own_file_descriptor, and sync().

gzfilebuf() [2/2]

gzfilebuf::gzfilebuf

(

)

~gzfilebuf() [2/2]

virtual gzfilebuf::~gzfilebuf ( )

virtual

Member Function Documentation

attach() [1/2]

gzfilebuf * gzfilebuf::attach	(	int	fd,
		std::ios_base::openmode	mode
	)

Attach to already open gzipped file.

Parameters

fd	File descriptor.
mode	Open mode flags.

Returns

this on success, NULL on failure.

Definition at line 79 of file zfstream.cc.

{
  // Fail if file already open
  if (this->is_open())
    return NULL;
  // Don't support simultaneous read/write access (yet)
  if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
    return NULL;
 
  // Build mode string for gzdopen and check it [27.8.1.3.2]
  char char_mode[6] = "\0\0\0\0\0";
  if (!this->open_mode(mode, char_mode))
    return NULL;
 
  // Attempt to attach to file
  if ((file = gzdopen(fd, char_mode)) == NULL)
    return NULL;
 
  // On success, allocate internal buffer and set flags
  this->enable_buffer();
  io_mode = mode;
  own_fd = false;
  return this;
}

References enable_buffer(), fd, gzdopen(), in, io_mode, is_open(), mode, NULL, open_mode(), out, and own_fd.

attach() [2/2]

gzfilebuf * gzfilebuf::attach	(	int	file_descriptor,
		int	io_mode
	)

Definition at line 60 of file zfstream.cpp.

                                            {
 
  if ( is_open() )
    return NULL;
 
  char char_mode[10];
  char *p = char_mode;
 
  if ( io_mode & ios::in ) {
    mode = ios::in;
    *p++ = 'r';
  } else if ( io_mode & ios::app ) {
    mode = ios::app;
    *p++ = 'a';
  } else {
    mode = ios::out;
    *p++ = 'w';
  }
 
  if ( io_mode & ios::binary ) {
    mode |= ios::binary;
    *p++ = 'b';
  }
 
  // Hard code the compression level
  if ( io_mode & (ios::out|ios::app )) {
    *p++ = '9';
  }
 
  // Put the end-of-string indicator
  *p = '\0';
 
  if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
    return NULL;
 
  own_file_descriptor = 0;
 
  return this;
 
}

References binary(), gzdopen(), in, io_mode, is_open(), NULL, out, own_file_descriptor, and p.

Referenced by gzifstream::attach(), and gzofstream::attach().

close() [1/2]

gzfilebuf * gzfilebuf::close

(

)

Definition at line 102 of file zfstream.cpp.

                            {
 
  if ( is_open() ) {
 
    sync();
    gzclose( file );
    file = NULL;
 
  }
 
  return this;
 
}

References gzclose(), is_open(), NULL, and sync().

Referenced by gzifstream::close(), gzofstream::close(), and ~gzfilebuf().

close() [2/2]

gzfilebuf* gzfilebuf::close

(

)

Close gzipped file.

Returns

this on success, NULL on failure.

disable_buffer()

void gzfilebuf::disable_buffer ( )

private

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.

Definition at line 347 of file zfstream.cc.

{
  // If internal buffer exists, deallocate it
  if (own_buffer && buffer)
  {
    // Preserve unbuffered status by zeroing size
    if (!this->pbase())
      buffer_size = 0;
    delete[] buffer;
    buffer = NULL;
    this->setg(0, 0, 0);
    this->setp(0, 0);
  }
  else
  {
    // Reset buffer pointers to initial state if external buffer exists
    this->setg(buffer, buffer, buffer);
    if (buffer)
      this->setp(buffer, buffer + buffer_size - 1);
    else
      this->setp(0, 0);
  }
}

References buffer, buffer_size, NULL, and own_buffer.

Referenced by setbuf().

enable_buffer()

void gzfilebuf::enable_buffer ( )

private

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.

Definition at line 308 of file zfstream.cc.

{
  // If internal buffer required, allocate one
  if (own_buffer && !buffer)
  {
    // Check for buffered vs. "unbuffered"
    if (buffer_size > 0)
    {
      // Allocate internal buffer
      buffer = new char_type[buffer_size];
      // Get area starts empty and will be expanded by underflow as need arises
      this->setg(buffer, buffer, buffer);
      // Setup entire internal buffer as put area.
      // The one-past-end pointer actually points to the last element of the buffer,
      // so that overflow(c) can safely add the extra character c to the sequence.
      // These pointers remain in place for the duration of the buffer
      this->setp(buffer, buffer + buffer_size - 1);
    }
    else
    {
      // Even in "unbuffered" case, (small?) get buffer is still required
      buffer_size = SMALLBUFSIZE;
      buffer = new char_type[buffer_size];
      this->setg(buffer, buffer, buffer);
      // "Unbuffered" means no put buffer
      this->setp(0, 0);
    }
  }
  else
  {
    // If buffer already allocated, reset buffer pointers just to make sure no
    // stale chars are lying around
    this->setg(buffer, buffer, buffer);
    this->setp(buffer, buffer + buffer_size - 1);
  }
}

References buffer_size, own_buffer, and SMALLBUFSIZE.

Referenced by attach(), open(), and setbuf().

fillbuf()

int gzfilebuf::fillbuf ( )

private

Definition at line 235 of file zfstream.cpp.

                       {
 
  int required;
  char *p;
 
  p = base();
 
  required = blen();
 
  int t = gzread( file, p, required );
 
  if ( t <= 0) return EOF;
 
  setg( base(), base(), base()+t);
 
  return t;
 
}

References gzread(), p, and cmd_descs_generate::required.

Referenced by underflow().

flushbuf()

int gzfilebuf::flushbuf ( )

private

Definition at line 218 of file zfstream.cpp.

                        {
 
  int n;
  char *q;
 
  q = pbase();
  n = pptr() - q;
 
  if ( gzwrite( file, q, n) < n )
    return EOF;
 
  setp(0,0);
 
  return 0;
 
}

References gzwrite(), and n.

Referenced by overflow(), sync(), and underflow().

is_open() [1/2]

int gzfilebuf::is_open ( ) const

inline

Definition at line 22 of file zfstream.h.

{ return (file !=NULL); }

References NULL.

Referenced by attach(), close(), gzifstream::is_open(), gzofstream::is_open(), open(), overflow(), showmanyc(), sync(), and underflow().

is_open() [2/2]

bool gzfilebuf::is_open ( ) const

inline

Check if file is open.

Returns

True if file is open.

Definition at line 57 of file zfstream.h.

{ return (file != NULL); }

References NULL.

open() [1/2]

gzfilebuf * gzfilebuf::open	(	const char *	name,
		int	io_mode
	)

Definition at line 18 of file zfstream.cpp.

                                          {
 
  if ( is_open() )
    return NULL;
 
  char char_mode[10];
  char *p = char_mode;
 
  if ( io_mode & ios::in ) {
    mode = ios::in;
    *p++ = 'r';
  } else if ( io_mode & ios::app ) {
    mode = ios::app;
    *p++ = 'a';
  } else {
    mode = ios::out;
    *p++ = 'w';
  }
 
  if ( io_mode & ios::binary ) {
    mode |= ios::binary;
    *p++ = 'b';
  }
 
  // Hard code the compression level
  if ( io_mode & (ios::out|ios::app )) {
    *p++ = '9';
  }
 
  // Put the end-of-string indicator
  *p = '\0';
 
  if ( (file = gzopen(name, char_mode)) == NULL )
    return NULL;
 
  own_file_descriptor = 1;
 
  return this;
 
}

References binary(), gzopen(), in, io_mode, is_open(), NULL, out, own_file_descriptor, and p.

Referenced by gzifstream::open(), and gzofstream::open().

open() [2/2]

gzfilebuf * gzfilebuf::open	(	const char *	name,
		std::ios_base::openmode	mode
	)

Open gzipped file.

Parameters

name	File name.
mode	Open mode flags.

Returns

this on success, NULL on failure.

Definition at line 51 of file zfstream.cc.

{
  // Fail if file already open
  if (this->is_open())
    return NULL;
  // Don't support simultaneous read/write access (yet)
  if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
    return NULL;
 
  // Build mode string for gzopen and check it [27.8.1.3.2]
  char char_mode[6] = "\0\0\0\0\0";
  if (!this->open_mode(mode, char_mode))
    return NULL;
 
  // Attempt to open file
  if ((file = gzopen(name, char_mode)) == NULL)
    return NULL;
 
  // On success, allocate internal buffer and set flags
  this->enable_buffer();
  io_mode = mode;
  own_fd = true;
  return this;
}

References enable_buffer(), gzopen(), in, io_mode, is_open(), mode, NULL, open_mode(), out, and own_fd.

open_mode()

bool gzfilebuf::open_mode ( std::ios_base::openmode  mode, char *  c_mode  ) const

protected

Convert ios open mode int to mode string used by zlib.

Returns

True if valid mode flag combination.

Definition at line 131 of file zfstream.cc.

{
  bool testb = mode & std::ios_base::binary;
  bool testi = mode & std::ios_base::in;
  bool testo = mode & std::ios_base::out;
  bool testt = mode & std::ios_base::trunc;
  bool testa = mode & std::ios_base::app;
 
  // Check for valid flag combinations - see [27.8.1.3.2] (Table 92)
  // Original zfstream hardcoded the compression level to maximum here...
  // Double the time for less than 1% size improvement seems
  // excessive though - keeping it at the default level
  // To change back, just append "9" to the next three mode strings
  if (!testi && testo && !testt && !testa)
    strcpy(c_mode, "w");
  if (!testi && testo && !testt && testa)
    strcpy(c_mode, "a");
  if (!testi && testo && testt && !testa)
    strcpy(c_mode, "w");
  if (testi && !testo && !testt && !testa)
    strcpy(c_mode, "r");
  // No read/write mode yet
//  if (testi && testo && !testt && !testa)
//    strcpy(c_mode, "r+");
//  if (testi && testo && testt && !testa)
//    strcpy(c_mode, "w+");
 
  // Mode string should be empty for invalid combination of flags
  if (strlen(c_mode) == 0)
    return false;
  if (testb)
    strcat(c_mode, "b");
  return true;
}

References binary(), in, and out.

Referenced by attach(), and open().

overflow() [1/2]

int gzfilebuf::overflow ( int  c = EOF )

protectedvirtual

Definition at line 173 of file zfstream.cpp.

                               {
 
  if ( !is_open() || !(mode & ios::out) )
    return EOF;
 
  if ( !base() ) {
    if ( allocate() == EOF )
      return EOF;
    setg(0,0,0);
  } else {
    if (in_avail()) {
        return EOF;
    }
    if (out_waiting()) {
      if (flushbuf() == EOF)
        return EOF;
    }
  }
 
  int bl = blen();
  setp( base(), base() + bl);
 
  if ( c != EOF ) {
 
    *pptr() = c;
    pbump(1);
 
  }
 
  return 0;
 
}

References allocate(), bl(), c, flushbuf(), is_open(), and out.

overflow() [2/2]

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

protectedvirtual

Write put area to gzipped file.

Parameters

c	Extra character to add to buffer contents.

Returns

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.

Definition at line 214 of file zfstream.cc.

{
  // Determine whether put area is in use
  if (this->pbase())
  {
    // Double-check pointer range
    if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
      return traits_type::eof();
    // Add extra character to buffer if not EOF
    if (!traits_type::eq_int_type(c, traits_type::eof()))
    {
      *(this->pptr()) = traits_type::to_char_type(c);
      this->pbump(1);
    }
    // Number of characters to write to file
    int bytes_to_write = this->pptr() - this->pbase();
    // Overflow doesn't fail if nothing is to be written
    if (bytes_to_write > 0)
    {
      // If the file hasn't been opened for writing, produce error
      if (!this->is_open() || !(io_mode & std::ios_base::out))
        return traits_type::eof();
      // If gzipped file won't accept all bytes written to it, fail
      if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)
        return traits_type::eof();
      // Reset next pointer to point to pbase on success
      this->pbump(-bytes_to_write);
    }
  }
  // Write extra character to file if not EOF
  else if (!traits_type::eq_int_type(c, traits_type::eof()))
  {
    // If the file hasn't been opened for writing, produce error
    if (!this->is_open() || !(io_mode & std::ios_base::out))
      return traits_type::eof();
    // Impromptu char buffer (allows "unbuffered" output)
    char_type last_char = traits_type::to_char_type(c);
    // If gzipped file won't accept this character, fail
    if (gzwrite(file, &last_char, 1) != 1)
      return traits_type::eof();
  }
 
  // If you got here, you have succeeded (even if c was EOF)
  // The return value should therefore be non-EOF
  if (traits_type::eq_int_type(c, traits_type::eof()))
    return traits_type::not_eof(c);
  else
    return c;
}

References c, gzwrite(), io_mode, is_open(), and out.

seekoff()

streampos gzfilebuf::seekoff ( streamoff  off, ios::seek_dir  dir, int  which  )

virtual

Definition at line 129 of file zfstream.cpp.

                                                                        {
 
  return streampos(EOF);
 
}

setbuf()

std::streambuf * gzfilebuf::setbuf ( char_type *  p, std::streamsize  n  )

protectedvirtual

Installs external stream buffer.

Parameters

p	Pointer to char buffer.
n	Size of external buffer.

Returns

this on success, NULL on failure.

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

Definition at line 266 of file zfstream.cc.

{
  // First make sure stuff is sync'ed, for safety
  if (this->sync() == -1)
    return NULL;
  // If buffering is turned off on purpose via setbuf(0,0), still allocate one...
  // "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at
  // least a buffer of size 1 (very inefficient though, therefore make it bigger?)
  // This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)
  if (!p || !n)
  {
    // Replace existing buffer (if any) with small internal buffer
    this->disable_buffer();
    buffer = NULL;
    buffer_size = 0;
    own_buffer = true;
    this->enable_buffer();
  }
  else
  {
    // Replace existing buffer (if any) with external buffer
    this->disable_buffer();
    buffer = p;
    buffer_size = n;
    own_buffer = false;
    this->enable_buffer();
  }
  return this;
}

References buffer_size, disable_buffer(), enable_buffer(), n, NULL, own_buffer, p, and sync().

setcompression()

int gzfilebuf::setcompression	(	int	comp_level,
		int	comp_strategy = Z_DEFAULT_STRATEGY
	)

Set compression level and strategy on the fly.

Parameters

comp_level	Compression level (see zlib.h for allowed values)
comp_strategy	Compression strategy (see zlib.h for allowed values)

Returns

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

Definition at line 43 of file zfstream.cc.

{
  return gzsetparams(file, comp_level, comp_strategy);
}

References gzsetparams().

setcompressionlevel()

int gzfilebuf::setcompressionlevel

(

int

comp_level

)

Definition at line 116 of file zfstream.cpp.

                                                   {
 
  return gzsetparams(file, comp_level, -2);
 
}

References gzsetparams().

setcompressionstrategy()

int gzfilebuf::setcompressionstrategy

(

int

comp_strategy

)

Definition at line 122 of file zfstream.cpp.

                                                         {
 
  return gzsetparams(file, -2, comp_strategy);
 
}

References gzsetparams().

showmanyc()

std::streamsize gzfilebuf::showmanyc ( )

protectedvirtual

Number of characters available in stream buffer.

Returns

Number of characters.

This indicates number of characters in get area of stream buffer. These characters can be read without accessing the gzipped file.

Definition at line 169 of file zfstream.cc.

{
  // Calls to underflow will fail if file not opened for reading
  if (!this->is_open() || !(io_mode & std::ios_base::in))
    return -1;
  // Make sure get area is in use
  if (this->gptr() && (this->gptr() < this->egptr()))
    return std::streamsize(this->egptr() - this->gptr());
  else
    return 0;
}

References in, io_mode, and is_open().

sync() [1/2]

int gzfilebuf::sync ( )

virtual

Definition at line 206 of file zfstream.cpp.

                    {
 
  if ( !is_open() )
    return EOF;
 
  if ( out_waiting() )
    return flushbuf();
 
  return 0;
 
}

References flushbuf(), and is_open().

Referenced by close(), setbuf(), and ~gzfilebuf().

sync() [2/2]

virtual int gzfilebuf::sync ( )

protectedvirtual

Flush stream buffer to file.

Returns

0 on success, -1 on error.

This calls underflow(EOF) to do the job.

underflow() [1/2]

gzfilebuf::int_type gzfilebuf::underflow ( )

protectedvirtual

Definition at line 135 of file zfstream.cpp.

                         {
 
  // If the file hasn't been opened for reading, error.
  if ( !is_open() || !(mode & ios::in) )
    return EOF;
 
  // if a buffer doesn't exists, allocate one.
  if ( !base() ) {
 
    if ( (allocate()) == EOF )
      return EOF;
    setp(0,0);
 
  } else {
 
    if ( in_avail() )
      return (unsigned char) *gptr();
 
    if ( out_waiting() ) {
      if ( flushbuf() == EOF )
        return EOF;
    }
 
  }
 
  // Attempt to fill the buffer.
 
  int result = fillbuf();
  if ( result == EOF ) {
    // disable get area
    setg(0,0,0);
    return EOF;
  }
 
  return (unsigned char) *gptr();
 
}

References allocate(), fillbuf(), flushbuf(), in, and is_open().

underflow() [2/2]

virtual int_type gzfilebuf::underflow ( )

protectedvirtual

Fill get area from gzipped file.

Returns

First character in get area on success, EOF on error.

This actually reads characters from gzipped file to stream buffer. Always buffered.

Member Data Documentation

buffer

char_type* gzfilebuf::buffer

private

Stream buffer.

For simplicity this remains allocated on the free store for the entire life span of the gzfilebuf object, unless replaced by setbuf.

Definition at line 207 of file zfstream.h.

Referenced by disable_buffer().

buffer_size

std::streamsize gzfilebuf::buffer_size

private

Stream buffer size.

Defaults to system default buffer size (typically 8192 bytes). Modified by setbuf.

Definition at line 215 of file zfstream.h.

Referenced by disable_buffer(), enable_buffer(), and setbuf().

file

gzFile gzfilebuf::file

private

Underlying file pointer.

Definition at line 35 of file zfstream.h.

io_mode

std::ios_base::openmode gzfilebuf::io_mode

private

Mode in which file was opened.

Definition at line 191 of file zfstream.h.

Referenced by attach(), open(), overflow(), and showmanyc().

mode

short gzfilebuf::mode

private

Definition at line 36 of file zfstream.h.

Referenced by attach(), open(), and test_group_name.GroupTest::run().

own_buffer

bool gzfilebuf::own_buffer

private

True if this object owns stream buffer.

This makes the class responsible for deleting the buffer upon destruction.

Definition at line 223 of file zfstream.h.

Referenced by disable_buffer(), enable_buffer(), and setbuf().

own_fd

bool gzfilebuf::own_fd

private

True if this object owns file descriptor.

This makes the class responsible for closing the file upon destruction.

Definition at line 199 of file zfstream.h.

Referenced by attach(), and open().

own_file_descriptor

short gzfilebuf::own_file_descriptor

private

Definition at line 37 of file zfstream.h.

Referenced by attach(), open(), and ~gzfilebuf().

---

The documentation for this class was generated from the following files:

• subprojects/zlib-1.2.12/contrib/iostream/zfstream.h
• subprojects/zlib-1.2.12/contrib/iostream/zfstream.cpp
• subprojects/zlib-1.2.12/contrib/iostream3/zfstream.cc