cheprep::DeflateOutputStreamBuffer Class Reference

#include <DeflateOutputStreamBuffer.h>

Inheritance diagram for cheprep::DeflateOutputStreamBuffer:

Collaboration diagram for cheprep::DeflateOutputStreamBuffer:

Public Member Functions
	DeflateOutputStreamBuffer (std::streambuf *buffer)
void	init (bool compress)
void	finish ()
virtual	~DeflateOutputStreamBuffer ()

Protected Member Functions
int	overflow (int c=EOF)
bool	flushOut ()
void	putUI (unsigned int ui)
void	putUS (unsigned short us)
void	putUB (unsigned char ub)
void	putS (const std::string s)
std::streampos	pos ()
unsigned int	getSize ()
unsigned int	getCRC ()

Detailed Description

Definition at line 20 of file DeflateOutputStreamBuffer.h.

Constructor & Destructor Documentation

cheprep::DeflateOutputStreamBuffer::DeflateOutputStreamBuffer

(

std::streambuf *

buffer

)

Definition at line 80 of file DeflateOutputStreamBuffer.cc.

            : buffer(aBuffer)
              , crc(0)
              , size(0)
#ifndef CHEPREP_NO_ZLIB               
              , zStreamOpen(false)
              , in(inSize)
              , out(outSize) 
#endif // CHEPREP_NO_ZLIB
              {
        
#ifndef CHEPREP_NO_ZLIB
        zStream.zalloc = Z_NULL;
        zStream.zfree = Z_NULL;
        zStream.opaque = Z_NULL;
        zStream.msg = 0;
        zStream.next_in = 0;
        zStream.next_out = 0;
        zStream.state = 0;
#endif // CHEPREP_NO_ZLIB
    }

cheprep::DeflateOutputStreamBuffer::~DeflateOutputStreamBuffer ( )

virtual

Definition at line 162 of file DeflateOutputStreamBuffer.cc.

                                                          {
    }

Member Function Documentation

void cheprep::DeflateOutputStreamBuffer::finish

(

)

Definition at line 129 of file DeflateOutputStreamBuffer.cc.

                                           {

#ifndef CHEPREP_NO_ZLIB        
        if (zStreamOpen) {

            overflow() ;

            zStream.next_out  = reinterpret_cast<unsigned char *>(&(out[0]));
            zStream.avail_out = outSize;
    
            int err = Z_OK ;
            while ( err == Z_OK ) {
                if (zStream.avail_out == 0) {
                    flushOut();
                }
                err = deflate(&zStream, Z_FINISH);
            }
        
            flushOut() ;
    
            if (err != Z_STREAM_END) {
                cerr << "ERROR: deflation failed" << endl;
            }
    
            if (deflateEnd(&zStream) != Z_OK) {
                cerr << "ERROR: deflateEnd failed" << endl;
            }
            
            zStreamOpen = false ;
        }      
#endif // CHEPREP_NO_ZLIB
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cheprep::DeflateOutputStreamBuffer::flushOut ( )

protected

Definition at line 234 of file DeflateOutputStreamBuffer.cc.

                                             {
        int deflatedCount = outSize - zStream.avail_out;
        int byteCount = buffer->sputn(&(out[0]), deflatedCount);

        zStream.next_out = reinterpret_cast<unsigned char *>(&(out[0]));
        zStream.avail_out = outSize ;

        return deflatedCount == byteCount ;
    }

Here is the caller graph for this function:

unsigned int cheprep::DeflateOutputStreamBuffer::getCRC ( )

inlineprotected

Definition at line 72 of file DeflateOutputStreamBuffer.h.

                                         {
                return crc;
            }

Here is the caller graph for this function:

unsigned int cheprep::DeflateOutputStreamBuffer::getSize ( )

inlineprotected

Definition at line 68 of file DeflateOutputStreamBuffer.h.

                                          {
                return size;
            }

Here is the caller graph for this function:

void cheprep::DeflateOutputStreamBuffer::init

(

bool

compress

)

Definition at line 103 of file DeflateOutputStreamBuffer.cc.

                                                      {

        if (compress) {
            if (zStreamOpen) return;
            
            zStream.next_in = reinterpret_cast<unsigned char *>(&(in[0]));
            zStream.avail_in = 0 ;
    
            zStream.next_out = reinterpret_cast<unsigned char *>(&(out[0]));
            zStream.avail_out = out.size();
    
            if (deflateInit2(&zStream, 6, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY ) != Z_OK) {
                cerr << "ERROR: deflateInit2 failed" << endl;
            } else {
                zStreamOpen = true;
                setp(&(in[0]), &(in[0])+inSize);
            }
        }
#else
    void DeflateOutputStreamBuffer::init(bool /*compress*/) {
#endif // CHEPREP_NO_ZLIB

        crc = 0;
        size = 0;
    }

Here is the caller graph for this function:

int cheprep::DeflateOutputStreamBuffer::overflow ( int  c = EOF )

protected

Definition at line 172 of file DeflateOutputStreamBuffer.cc.

                                                 {

#ifndef CHEPREP_NO_ZLIB        
        if (zStreamOpen) {
            zStream.avail_in = pptr() - pbase() ;
            zStream.next_in = reinterpret_cast<unsigned char *>(&(in[0]));
        
            int len = zStream.avail_in;
            unsigned char* buf = zStream.next_in;
        
            crc = crc ^ 0xffffffffUL;
            while (len >= 8) {
                DO8;
                len -= 8;
            }
            if (len) do {
                DO1;
            } while (--len);
            crc = crc ^ 0xffffffffUL;
    
            size += zStream.avail_in;

            zStream.next_out  = reinterpret_cast<unsigned char *>(&(out[0]));
            zStream.avail_out = outSize ;
        
            int err = Z_OK ;
            while ((zStream.avail_in > 0 || zStream.avail_out == 0) && err == Z_OK) {
                if (zStream.avail_out == 0 ) {
                    flushOut();
                }
                err = deflate(&zStream, Z_NO_FLUSH);
            }

            flushOut();
        
            setp(&(in[0]), &(in[0]) + inSize);

            if ((err != Z_OK) && (err != Z_STREAM_END)) {
                cerr << "ERROR: deflation failed" << endl;
                return EOF ;
            }

            if ( c != EOF ) {
                *pptr() = c ;
                pbump(1);
            }
    
            return 0 ;
        } else {
#endif // CHEPREP_NO_ZLIB
            crc = crc ^ 0xffffffffUL;
            crc = crctable[(crc ^ c) & 0xff] ^ (crc >> 8);
            crc = crc ^ 0xffffffffUL;
            size++;
            return buffer->sputc((char)c);
#ifndef CHEPREP_NO_ZLIB        
        }
#endif // CHEPREP_NO_ZLIB
    }

Here is the call graph for this function:

Here is the caller graph for this function:

std::streampos cheprep::DeflateOutputStreamBuffer::pos ( )

inlineprotected

Definition at line 63 of file DeflateOutputStreamBuffer.h.

                                      {
                std::ostream os(buffer);
                return os.tellp();
            }

Here is the caller graph for this function:

void cheprep::DeflateOutputStreamBuffer::putS ( const std::string  s )

inlineprotected

Definition at line 59 of file DeflateOutputStreamBuffer.h.

                                                {
                buffer->sputn(s.c_str(), s.length());                
            }

Here is the caller graph for this function:

void cheprep::DeflateOutputStreamBuffer::putUB ( unsigned char  ub )

inlineprotected

Definition at line 55 of file DeflateOutputStreamBuffer.h.

                                                {
                buffer->sputc(ub);
            }

void cheprep::DeflateOutputStreamBuffer::putUI ( unsigned int  ui )

inlineprotected

Definition at line 39 of file DeflateOutputStreamBuffer.h.

                                               {
                unsigned char* ucp = reinterpret_cast<unsigned char *>(&ui);
                unsigned int i   = (static_cast<unsigned int>(ucp[ 3 ]) << 24) +  
                                   (static_cast<unsigned int>(ucp[ 2 ]) << 16) + 
                                   (static_cast<unsigned int>(ucp[ 1 ]) << 8 ) + 
                                   (static_cast<unsigned int>(ucp[ 0 ]));                   
                buffer->sputn(reinterpret_cast<char *>(&i), sizeof(unsigned int));
            }

Here is the caller graph for this function:

void cheprep::DeflateOutputStreamBuffer::putUS ( unsigned short  us )

inlineprotected

Definition at line 48 of file DeflateOutputStreamBuffer.h.

                                                 {
                unsigned char* ucp = reinterpret_cast<unsigned char *>(&us);
                unsigned short s   = (static_cast<unsigned short>(ucp[ 1 ]) << 8 ) + 
                                     (static_cast<unsigned short>(ucp[ 0 ]));                   
                buffer->sputn(reinterpret_cast<char *>(&s), sizeof(unsigned short));
            }

Here is the caller graph for this function:

---

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

• geant4.10.03.p01/source/visualization/HepRep/include/cheprep/DeflateOutputStreamBuffer.h
• geant4.10.03.p01/source/visualization/HepRep/src/DeflateOutputStreamBuffer.cc