---

zipbuffer.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  ZIPBUFFER.CPP
//----------------------------------------------------------------------------- 
//_____________________________________________________________________________
//
//  Copyright (C) 2003 Guillaume Baurand. All Rights Reserved.
//
//  This file is part of the XDFLengine project.
//
//  The XDFLengine is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
//  USA.
//
//  For more information, 
//      contact  : guillaume@baurand.net 
//      or visit : http://xdflengine.sourceforge.net
//
//============================================================================= 

#   include "zipbuffer.hpp"

BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS ZIPBUFFER
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_____________________________________________________________________
    //  Settmpdir
    //--------------------------------------------------------------------- 
    void ZipBuffer::setTmpDir( const char* p_pszTmpDir)
    {
        gs_pszZipBufferTmpDir = p_pszTmpDir;
    }


    //_________________________________________________________________________
    //  ZIPBUFFER
    //-------------------------------------------------------------------------
    ZipBuffer::ZipBuffer(const char* p_cFileName, bool p_boolReadOnly, unsigned int p_uiBufferSize)
    {
        m_boolReadOnly=p_boolReadOnly;
        m_bOwnFile=false;
        m_bOpened=false;
        m_uiBufferSize=p_uiBufferSize;
        if( m_uiBufferSize == 0 ) m_uiBufferSize = ZIPBUFFER_COPYBUF;
        // Set default file open mode
        setMode("ab");
        m_pOut=0;

        if( p_cFileName) strcpy( (char*) &m_cFN, p_cFileName);
        else
        {
            // Build file name
            strcpy((char*) &m_cFN,gs_pszZipBufferTmpDir);
            tmpnam((char*) &m_cFN+strlen(gs_pszZipBufferTmpDir));   
            m_bOwnFile=true;
            flush();
        }

        DEBUG_CREATE(ZipBuffer)
    }

    //_________________________________________________________________________
    //  ~ZIPBUFFER
    //-------------------------------------------------------------------------
    ZipBuffer::~ZipBuffer()
    {
        DEBUG_DEL(ZipBuffer)

        DEBUG_ECHO << "delete buffer " << m_cFN << "\n";

        closefile();
        if(m_bOwnFile && !m_boolReadOnly) delFile();

        m_boolReadOnly=false;
        m_bOwnFile=false;
        m_bOpened=false;
        m_pOut=0;       
    }


    //_________________________________________________________________________
    //  OPERATOR >>
    //-------------------------------------------------------------------------
    XMLStreamProvider & ZipBuffer::operator>>   ( XMLStreamConsumer& p_pStreamConsumer)
    {
        //---------------------------------------------------------------------
        void*           l_cBuf=0;
        int             l_intRead;
        int             l_intTotRead;
        unsigned int    l_written;
        int             l_intError;
        const char*     l_cError=0;
        //---------------------------------------------------------------------


        DEBUG_IN(ZipBuffer::>>(XMLStreamBuffer))
        PREP_CATCH_XML_FLOW_ERROR;

        WATCH_XML_FLOW_ERROR
        { 
            setMode("rb");
            openfile();

            // rewind file
            if( gzrewind(m_pOut) == -1) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_ZIPBUFFER + ERRCODE_CAUSE_FILE , "Unable rewind gz file.", m_cFN, "ZipBuffer::operator>>", "", false );

            // allocate copy buffer
            l_cBuf = malloc(m_uiBufferSize+1);

            l_intRead=-1;
            l_intTotRead=0;
            l_written=0;

            while( !( gzeof(m_pOut) || (l_intRead==0) ) )
            {
                // read data from compressed file
                logout << "\t" << (char*) &m_cFN  << "   :   " << "read " << l_intRead << " bytes from compressed file.\n";
                l_intRead = gzread(m_pOut, l_cBuf, m_uiBufferSize);

                // ERRCHECK : read data
                if( l_intRead == -1) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_ZIPBUFFER + ERRCODE_CAUSE_FILE ,"Unable read data from gz file." ,m_cFN, "ZipBuffer::operator>>", "", false );
                
                if(l_intRead > 0)
                {
                    l_intTotRead+=l_intRead;
                    l_written+=l_intRead;

                    // Write file content to output buffer  
                    p_pStreamConsumer.writeData((const char*)l_cBuf,l_intRead);
                    p_pStreamConsumer.commitStream(false);
                }
                l_intError=0;
                l_cError = gzerror(m_pOut, &l_intError);                
            }
            closefile();
        }
        CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;    

    RELEASE_AND_RETURN: 

        // Release
        free( l_cBuf);

        DEBUG_OUT(ZipBuffer::>>(XMLStreamBuffer))       
        ON_XML_FLOW_ERROR_THROW;
        
        return *this;
    }


    //_________________________________________________________________________
    //  FLUSH
    //-------------------------------------------------------------------------
    void ZipBuffer::flush ()
    {
        DEBUG_FUNC(ZipBuffer::flush)
        
        if (!m_boolReadOnly)
        {
            logout << "\t" << (char*) &m_cFN  << "   :   " << "flush compressed file.\n";

            closefile();
            delFile();
            setMode("ab");
        }
    }


    //_________________________________________________________________________
    //  writeData
    //-------------------------------------------------------------------------
    void ZipBuffer::writeData( const char*  p_pszData, unsigned int p_uiDataLen)
    {
        //---------------------------------------------------------------------
        int         l_intwritten;
        int         l_intError;
        //---------------------------------------------------------------------

        if (!m_boolReadOnly && (p_uiDataLen>0) )
        {
            setMode("ab");
            openfile();

            // write data to file
            l_intwritten=gzwrite( m_pOut, (void*) p_pszData, p_uiDataLen );
            if( l_intwritten == 0) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_ZIPBUFFER + ERRCODE_CAUSE_FILE , "Unable to write data to gz file." , m_cFN, "ZipBuffer::write", "", false );
            
            m_commitwritten+=l_intwritten;

            l_intError=0;
            gzerror(m_pOut, &l_intError);
            if (l_intError) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_ZIPBUFFER + ERRCODE_CAUSE_FILE , "Unable to write data to gz file.",m_cFN, "ZipBuffer::write", "", false );
        }
    }


    //_____________________________________________________________________
    //  COMMITSTREAM
    //---------------------------------------------------------------------
    //_____________________________________________________________________ 
    bool ZipBuffer::commitStream(bool fFinal)
    {
        if (m_bOpened && !m_boolReadOnly && m_commitwritten>0)
        {
            logout << "\t" << (char*) &m_cFN  << "   :   " << "write " << m_commitwritten << " bytes to compressed file.\n";
            // flush data
            if( gzflush(m_pOut,Z_SYNC_FLUSH ) !=0 ) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_ZIPBUFFER + ERRCODE_CAUSE_FILE , "Unable to flush data to gz file.", m_cFN, "ZipBuffer::write", "", false );          
            if( fFinal) closefile();
        }
        m_commitwritten=0;

        return true;
    }



    //_________________________________________________________________________
    //  SETMODE
    //-------------------------------------------------------------------------
    void ZipBuffer::setMode( const char* p_cMode)
    {
        if(strcmp(p_cMode,m_cMode)!=0) 
        {
            closefile();
            strcpy( m_cMode, p_cMode);
        }
    }

    //_________________________________________________________________________
    //  OPENFILE
    //-------------------------------------------------------------------------
    void ZipBuffer::openfile()
    {
        if( !m_bOpened)
        {           
            
            try{

                logout << "\t" << (char*) &m_cFN  << "   :   " << "open compressed file.\n";
                if( ! m_boolReadOnly) m_pOut=gzopen( m_cFN, m_cMode);
                else m_pOut=gzopen( m_cFN, "rb");
                m_bOpened=true;
            }
            catch(...){}
            
            if( !m_bOpened)  m_pOut=0;
            if( !m_pOut) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_ZIPBUFFER + ERRCODE_CAUSE_FILE , "Unable to open file." , m_cFN, "ZipBuffer::openfile", "", false );         

            m_commitwritten=0;
        }
    }

    //_________________________________________________________________________
    //  CLOSEFILE
    //-------------------------------------------------------------------------
    void ZipBuffer::closefile()
    {
        
        if( m_bOpened && (m_pOut !=0 ) )
        {
            logout << "\t" << (char*) &m_cFN  << "   :   " << "close compressed file.\n";
            if( gzclose(m_pOut) !=0 ) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_ZIPBUFFER + ERRCODE_CAUSE_FILE , "Unable to close file.", m_cFN, "ZipBuffer::closefile", "", false );
            m_bOpened=false;
        }   
    }

    //_____________________________________________________________________
    //  DELFILE
    //---------------------------------------------------------------------
    void ZipBuffer::delFile()
    {   
        if( strlen((const char*) &m_cFN)>0)
        {
            closefile();
            logout << "\t" << (char*) &m_cFN  << "   :   " << "delete compressed file.\n";
            remove( (const char*) &m_cFN);
        }
    }

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//============================================================================= 

END_XDFLENGINE_NS

---