---

filebuffer.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//----------------------------------------------------------------------------- 
//  FILEBUFFER.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 <sys/stat.h>
#   include "filebuffer.hpp"


BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS FILEBUFFER
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


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

// CONSTRUCTOR & DESTRUCTOR
    //_________________________________________________________________________
    //  FILEBUFFER
    //-------------------------------------------------------------------------
    FileBuffer::FileBuffer(const char* p_cFileName, bool p_boolReadOnly, unsigned int p_uiBufferSize)
    {
        m_boolReadOnly=p_boolReadOnly;
        m_bOpened=false;
        m_uiBufferSize=p_uiBufferSize;
        if( m_uiBufferSize == 0 ) m_uiBufferSize = FILEBUFFER_COPYBUF;
        m_pOut=0;

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

        // Set default file open mode
        setMode("ab");

        DEBUG_CREATE(FileBuffer)

    }

    //_________________________________________________________________________
    //  ~FILEBUFFER
    //-------------------------------------------------------------------------
    FileBuffer::~FileBuffer()
    {
        DEBUG_DEL(FileBuffer)
        DEBUG_ECHO << "delete buffer " << m_cFN << "\n";

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


// XMLSTREAMPROVIDER

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

        DEBUG_IN(FileBuffer::>>(XMLStreamConsumer))

        PREP_CATCH_XML_FLOW_ERROR;

        WATCH_XML_FLOW_ERROR {

            setMode("rb");
            openfile();
            rewind(m_pOut);         

            l_intRead=-1;
            l_intTotRead=0;
            l_written=0;
            l_cBuf = malloc(m_uiBufferSize+1);

            while( !( feof(m_pOut) || (l_intRead==0) ) )
            {
                l_intRead = fread( l_cBuf, 1, m_uiBufferSize, m_pOut);
                l_intTotRead+=l_intRead;

                logout << "\t" << (char*) &m_cFN  << "   :   " << "read " << l_intRead << "bytes.\n";

                if(l_intRead!=0)
                {
                    l_written+=l_intRead;
                    // Write file content to output buffer  
                    p_pStreamConsumer.writeData((const char*)l_cBuf,l_intRead);
                    p_pStreamConsumer.commitStream(false);
                }

                // ERRCHECK : read file (tested)
                if (ferror(m_pOut)) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FILEBUFFER + ERRCODE_CAUSE_FILE , "Unable to read from file.", m_cFN,  "FileBuffer::operator>>", "", false );                 
            }
    
            closefile();

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;
        
    RELEASE_AND_RETURN: 

        // Release
        free( l_cBuf);

        DEBUG_OUT(FileBuffer::>>(XMLStreamConsumer))
            
        ON_XML_FLOW_ERROR_THROW;    

        return *this;
    }

// XMLSTREAMCONSUMER

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

        DEBUG_FUNC(FileBuffer::write)

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

            l_intwritten=fwrite( p_pszData, 1, p_uiDataLen, m_pOut);
            m_commitwritten+=l_intwritten;          

            // ERRCHECK : write to file (tested)
            if ( (l_intwritten==0) || (ferror(m_pOut))) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FILEBUFFER + ERRCODE_CAUSE_FILE , "Unable to write to file." , m_cFN, "FileBuffer::write", "", false );   
        }
    }


    //_____________________________________________________________________
    //  COMMITSTREAM
    //---------------------------------------------------------------------
    //_____________________________________________________________________ 
    bool FileBuffer::commitStream(bool fFinal)
    {
        if (m_bOpened && !m_boolReadOnly && m_commitwritten>0)
        {
            logout << "\t" << (char*) &m_cFN  << "   :   " << "write " << m_commitwritten << " bytes.\n";
            fflush(m_pOut);
            if( fFinal) closefile();
        }
        m_commitwritten=0;

        return true;
    }

// FILEBUFFER

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

// PRIVATES

    //_________________________________________________________________________
    //  OPENFILE
    //-------------------------------------------------------------------------
    void FileBuffer::openfile()
    {
        DEBUG_FUNC(FileBuffer::openfile)
            
        PREP_CATCH_XML_FLOW_ERROR;

        WATCH_XML_FLOW_ERROR
        {
            if( !m_bOpened)
            {   
                m_commitwritten=0;              
                // open file

                logout << "\t" << (char*) &m_cFN  << "   :   " <<  "open file.\n";
                if( ! m_boolReadOnly) m_pOut=fopen( m_cFN, m_cMode);
                else m_pOut=fopen( m_cFN, "rb");
                m_bOpened=true;

                // ERRCHECK : open file
                if((!m_bOpened) || ferror(m_pOut) || (!m_pOut))
                {
                    THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FILEBUFFER + ERRCODE_CAUSE_FILE , "Unable to open file." , m_cFN, "FileBuffer::openfile", "", false );
                }

            }
        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN
        catch(...)
        {
            m_bOpened=false;
            THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FILEBUFFER + ERRCODE_CAUSE_FILE , "Unable to open file.", m_cFN, "FileBuffer::openfile", "", false );
        }       

    RELEASE_AND_RETURN: 
    
        ON_XML_FLOW_ERROR_THROW;
    }

    //_________________________________________________________________________
    //  CLOSEFILE
    //-------------------------------------------------------------------------
    void FileBuffer::closefile()
    {
        if( m_bOpened && (m_pOut !=0 ) )
        {
            logout << "\t" << (char*) &m_cFN  << "   :   " << "close file.\n";

            if( fclose(m_pOut) !=0 ) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FILEBUFFER + ERRCODE_CAUSE_FILE , "Unable to close file.", m_cFN, "FileBuffer::closefile", "", false );
            m_bOpened=false;            
        }       
    }


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


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

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

END_XDFLENGINE_NS

---