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