---

membuffer.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//----------------------------------------------------------------------------- 
//  MEMBUFFER.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 "membuffer.hpp"

BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS MEMBUFFER
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// CONSTRUCTOR & DESTRUCTOR

    //_________________________________________________________________________
    //  MEMBUFFER
    //-------------------------------------------------------------------------
    MemBuffer::MemBuffer()
    {       
        m_intSize=0;
        m_bBuf=0;
        m_uiBufSize=0;

        DEBUG_CREATE(MemBuffer)
    }

    //_________________________________________________________________________
    //  ~MEMBUFFER
    //-------------------------------------------------------------------------
    MemBuffer::~MemBuffer()
    {
        DEBUG_DEL(MemBuffer)

        if(m_bBuf) free(m_bBuf);
    }

// XMLSTREAMPROVIDER

    //_________________________________________________________________________
    //  OPERATOR >>
    //-------------------------------------------------------------------------
    XMLStreamProvider & MemBuffer::operator>>   ( XMLStreamConsumer& p_pStreamConsumer)
    {
        DEBUG_FUNC(MemBuffer::>>(XMLStreamBuffer))

        if(length()>0) p_pStreamConsumer.writeData( (const char*) m_bBuf, length());  
        p_pStreamConsumer.commitStream(false); 
        return *this;
    }


// XMLSTREAMCONSUMER


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

        DEBUG_FUNC(MemBuffer::writeData)

        if(p_uiDataLen>0)
        {
            if( (unsigned int)(m_intSize+p_uiDataLen) >= m_uiBufSize)
            {
                l_uiNewBufSize = m_uiBufSize;
                if(l_uiNewBufSize==0) l_uiNewBufSize=128;
                while( l_uiNewBufSize-m_intSize-1 < p_uiDataLen) l_uiNewBufSize = l_uiNewBufSize*2;
                m_uiBufSize = l_uiNewBufSize;
                m_bBuf = realloc( m_bBuf, m_uiBufSize+1);
                if( m_bBuf == NULL) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_MEMBUFFER + ERRCODE_CAUSE_MEMORY , "Unable to allocate mem buffer." , "",  "MemBuffer::write", "", false );
            }

            memcpy((char*)m_bBuf + m_intSize, p_pszData, p_uiDataLen);
            m_intSize+=p_uiDataLen;
            ((char*)m_bBuf)[m_intSize]='\0';
        }
    }



// MEMBUFFER

    //_________________________________________________________________________
    //  FLUSH
    //-------------------------------------------------------------------------
    void MemBuffer::flush ()
    {
        DEBUG_FUNC(MemBuffer::flush)

        if(m_bBuf) free(m_bBuf);
        m_bBuf=0;
        m_intSize=0;
        m_uiBufSize=0; 
    }

    //_________________________________________________________________________
    //  LENGTH
    //-------------------------------------------------------------------------
    int MemBuffer::length() const
    {
        DEBUG_FUNC(MemBuffer::length)

        return m_intSize;
    }

    //_________________________________________________________________________
    //  DATA
    //-------------------------------------------------------------------------
    const char* MemBuffer::data() const
    {
        DEBUG_FUNC(MemBuffer::data);
        if(m_bBuf) return (const char*) m_bBuf;
        return 0;
    }




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

END_XDFLENGINE_NS

---