zlib/contrib/iostream/zfstream.cpp

Go to the documentation of this file.

 
#include "zfstream.h"
 
gzfilebuf::gzfilebuf() :
  file(NULL),
  mode(0),
  own_file_descriptor(0)
{ }
 
gzfilebuf::~gzfilebuf() {
 
  sync();
  if ( own_file_descriptor )
    close();
 
}
 
gzfilebuf *gzfilebuf::open( const char *name,
                            int io_mode ) {
 
  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;
 
}
 
gzfilebuf *gzfilebuf::attach( int file_descriptor,
                              int io_mode ) {
 
  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;
 
}
 
gzfilebuf *gzfilebuf::close() {
 
  if ( is_open() ) {
 
    sync();
    gzclose( file );
    file = NULL;
 
  }
 
  return this;
 
}
 
int gzfilebuf::setcompressionlevel( int comp_level ) {
 
  return gzsetparams(file, comp_level, -2);
 
}
 
int gzfilebuf::setcompressionstrategy( int comp_strategy ) {
 
  return gzsetparams(file, -2, comp_strategy);
 
}
 
 
streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {
 
  return streampos(EOF);
 
}
 
int gzfilebuf::underflow() {
 
  // 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();
 
}
 
int gzfilebuf::overflow( int c ) {
 
  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;
 
}
 
int gzfilebuf::sync() {
 
  if ( !is_open() )
    return EOF;
 
  if ( out_waiting() )
    return flushbuf();
 
  return 0;
 
}
 
int gzfilebuf::flushbuf() {
 
  int n;
  char *q;
 
  q = pbase();
  n = pptr() - q;
 
  if ( gzwrite( file, q, n) < n )
    return EOF;
 
  setp(0,0);
 
  return 0;
 
}
 
int gzfilebuf::fillbuf() {
 
  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;
 
}
 
gzfilestream_common::gzfilestream_common() :
  ios( gzfilestream_common::rdbuf() )
{ }
 
gzfilestream_common::~gzfilestream_common()
{ }
 
void gzfilestream_common::attach( int fd, int io_mode ) {
 
  if ( !buffer.attach( fd, io_mode) )
    clear( ios::failbit | ios::badbit );
  else
    clear();
 
}
 
void gzfilestream_common::open( const char *name, int io_mode ) {
 
  if ( !buffer.open( name, io_mode ) )
    clear( ios::failbit | ios::badbit );
  else
    clear();
 
}
 
void gzfilestream_common::close() {
 
  if ( !buffer.close() )
    clear( ios::failbit | ios::badbit );
 
}
 
gzfilebuf *gzfilestream_common::rdbuf()
{
  return &buffer;
}
 
gzifstream::gzifstream() :
  ios( gzfilestream_common::rdbuf() )
{
  clear( ios::badbit );
}
 
gzifstream::gzifstream( const char *name, int io_mode ) :
  ios( gzfilestream_common::rdbuf() )
{
  gzfilestream_common::open( name, io_mode );
}
 
gzifstream::gzifstream( int fd, int io_mode ) :
  ios( gzfilestream_common::rdbuf() )
{
  gzfilestream_common::attach( fd, io_mode );
}
 
gzifstream::~gzifstream() { }
 
gzofstream::gzofstream() :
  ios( gzfilestream_common::rdbuf() )
{
  clear( ios::badbit );
}
 
gzofstream::gzofstream( const char *name, int io_mode ) :
  ios( gzfilestream_common::rdbuf() )
{
  gzfilestream_common::open( name, io_mode );
}
 
gzofstream::gzofstream( int fd, int io_mode ) :
  ios( gzfilestream_common::rdbuf() )
{
  gzfilestream_common::attach( fd, io_mode );
}
 
gzofstream::~gzofstream() { }