gzstreambuf Class Reference

#include <gzstream.h>

Inheritance diagram for gzstreambuf:

Public Member Functions
	gzstreambuf ()
int	is_open () const
	~gzstreambuf ()
gzstreambuf *	open (const char *name, int open_mode)
gzstreambuf *	close ()
virtual int	underflow ()
virtual int	overflow (int c=EOF)
virtual int	sync ()

Private Member Functions
int	flush_buffer ()

Private Attributes
gzFile	file
char	buffer [bufferSize]
char	opened
int	mode

Static Private Attributes
static const int	bufferSize = 47+256

Detailed Description

Author

mdejong

Definition at line 51 of file gzstream.h.

Constructor & Destructor Documentation

gzstreambuf()

gzstreambuf::gzstreambuf ( )

inline

Definition at line 72 of file gzstream.h.

                  : opened(0) {
      setp( buffer, buffer + (bufferSize-1));
      setg( buffer + 4,     // beginning of putback area
            buffer + 4,     // read position
            buffer + 4);    // end position      
      // ASSERT: both input & output capabilities will not be used together
    }

~gzstreambuf()

gzstreambuf::~gzstreambuf ( )

inline

Definition at line 81 of file gzstream.h.

{ close(); }

Member Function Documentation

flush_buffer()

int gzstreambuf::flush_buffer ( )

inlineprivate

Definition at line 62 of file gzstream.h.

                       {
      // Separate the writing of the buffer from overflow() and
      // sync() operation.
      int w = pptr() - pbase();
      if ( gzwrite( file, pbase(), w) != w)
        return EOF;
      pbump( -w);
      return w;
    }

is_open()

int gzstreambuf::is_open ( ) const

inline

Definition at line 79 of file gzstream.h.

{ return opened; }

open()

gzstreambuf * gzstreambuf::open ( const char * name, int open_mode )

inline

Definition at line 82 of file gzstream.h.

                                                        {
      if ( is_open())
        return (gzstreambuf*)0;
      mode = open_mode;
      // no append nor read/write mode
      if ((mode & std::ios::ate) || (mode & std::ios::app)
          || ((mode & std::ios::in) && (mode & std::ios::out)))
        return (gzstreambuf*)0;
      char  fmode[10];
      char* fmodeptr = fmode;
      if ( mode & std::ios::in)
        *fmodeptr++ = 'r';
      else if ( mode & std::ios::out)
        *fmodeptr++ = 'w';
      *fmodeptr++ = 'b';
      *fmodeptr = '\0';
      file = gzopen( name, fmode);
      if (file == 0)
        return (gzstreambuf*)0;
      opened = 1;
      setg( buffer + 4,     // beginning of putback area
            buffer + 4,     // read position
            buffer + 4);    // end position      
      return this;
    }

close()

gzstreambuf * gzstreambuf::close ( )

inline

Definition at line 108 of file gzstream.h.

                          {
      if ( is_open()) {
        sync();
        opened = 0;
        if ( gzclose( file) == Z_OK)
          return this;
      }
      return (gzstreambuf*)0;
    }

underflow()

virtual int gzstreambuf::underflow ( )

inlinevirtual

Definition at line 118 of file gzstream.h.

                            { // used for input buffer only
      if ( gptr() && ( gptr() < egptr()))
        return * reinterpret_cast<unsigned char *>( gptr());
        
      if ( ! (mode & std::ios::in) || ! opened)
        return EOF;
      // Josuttis' implementation of inbuf
      int n_putback = gptr() - eback();
      if ( n_putback > 4)
        n_putback = 4;
      memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
        
      int num = gzread( file, buffer+4, bufferSize-4);
      if (num <= 0) // ERROR or EOF
        return EOF;
        
      // reset buffer pointers
      setg( buffer + (4 - n_putback),   // beginning of putback area
            buffer + 4,                 // read position
            buffer + 4 + num);          // end of buffer
        
      // return next character
      return * reinterpret_cast<unsigned char *>( gptr());    
    }

overflow()

virtual int gzstreambuf::overflow ( int c = EOF )

inlinevirtual

Definition at line 143 of file gzstream.h.

                                     { // used for output buffer only
      if ( ! ( mode & std::ios::out) || ! opened)
        return EOF;
      if (c != EOF) {
        *pptr() = c;
        pbump(1);
      }
      if ( flush_buffer() == EOF)
        return EOF;
      return c;
    }

sync()

virtual int gzstreambuf::sync ( )

inlinevirtual

Definition at line 155 of file gzstream.h.

                       {
      // Changed to use flush_buffer() instead of overflow( EOF)
      // which caused improper behavior with std::endl and flush(),
      // bug reported by Vincent Ricard.
      if ( pptr() && pptr() > pbase()) {
        if ( flush_buffer() == EOF)
          return -1;
      }
      return 0;
    }    

Member Data Documentation

bufferSize

const int gzstreambuf::bufferSize = 47+256

staticprivate

Definition at line 53 of file gzstream.h.

file

gzFile gzstreambuf::file

private

Definition at line 56 of file gzstream.h.

buffer

char gzstreambuf::buffer[bufferSize]

private

Definition at line 57 of file gzstream.h.

opened

char gzstreambuf::opened

private

Definition at line 58 of file gzstream.h.

mode

int gzstreambuf::mode

private

Definition at line 59 of file gzstream.h.

---

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

• gzstream.h