---

xmlflowcontext.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  XMLFLOWCONTEXT.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 "xmlflowcontext.hpp"
#   include "processor/xmlprocessor.hpp"
#   include <xercesc/util/PlatformUtils.hpp>
#   include <xercesc/util/XMLUniDefs.hpp>
#   include <xercesc/util/XMLString.hpp>
#   include <xercesc/util/TransService.hpp>
#   include <xercesc/util/TranscodingException.hpp>

BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS XMLFlowContext
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


//  CONSTRUCTORS AND DESTRUCTOR  

    //_________________________________________________________________________
    //  XMLFlowContext
    //-------------------------------------------------------------------------
    XMLFlowContext::XMLFlowContext( const XMLProcessor* p_pXMLProcessor, const XMLFlowContext* p_pParent, unsigned int p_uiThreadId , const char* p_pszEncoding )
    {

        XMLTransService::Codes l_resCode;
        unsigned int l_TmpBufSize;
        XMLCh* l_fOutEncoding;

        // Init pointers
        m_pXMLProcessor = p_pXMLProcessor;
        m_uiThreadId = p_uiThreadId;
                if(!p_pszEncoding) p_pszEncoding = CHAR_ENCODING_DEFAULT;
        m_pszEncoding = importCharBuffer(0,  p_pszEncoding);
        m_pParent = p_pParent;

        // Try to create a transcoder for this encoding
        l_TmpBufSize     = 16 * 1024;           
        l_fOutEncoding = STRX( m_pszEncoding);
                DEBUG_ECHO << "Create transcoder for " << m_pszEncoding << "\n";
        m_fXCoder = XMLPlatformUtils::fgTransService->makeNewTranscoderFor( l_fOutEncoding, l_resCode, l_TmpBufSize,XMLPlatformUtils::fgMemoryManager);
        delete[] l_fOutEncoding;

        DEBUG_CREATE(XMLFlowContext)
    }

    //_________________________________________________________________________
    //  ~XMLFlowContext
    //-------------------------------------------------------------------------
    XMLFlowContext::~XMLFlowContext()
    {       
        DEBUG_DEL(XMLFlowContext)
    
        delete m_fXCoder;
        m_pszEncoding = releaseCharBuffer( m_pszEncoding);

        releaseParameters();
        releaseBuffers();       
    }

    //_____________________________________________________________________
    //  SETPROCESSOR
    //---------------------------------------------------------------------
    void XMLFlowContext::setProcessor(const XMLProcessor* p_pXMLProcessor)
    {
        m_pXMLProcessor = p_pXMLProcessor;
    }


    //_____________________________________________________________________
    //  GETPROCESSOR
    //---------------------------------------------------------------------
    const XMLProcessor* XMLFlowContext::getProcessor()
    {
        return m_pXMLProcessor;
    }


    //_____________________________________________________________________
    //  SETPARENT
    //---------------------------------------------------------------------
    void XMLFlowContext::setParent(const XMLFlowContext* p_pParent)
    {
        m_pParent = p_pParent;
    }


    //_____________________________________________________________________
    //  GETPARENT
    //---------------------------------------------------------------------
    const XMLFlowContext* XMLFlowContext::getParent()
    {
        return m_pParent;
    }

// GETTERS


    //_____________________________________________________________________
    //  GETTHREADID
    //---------------------------------------------------------------------
    unsigned int XMLFlowContext::getThreadId() const
    {
        DEBUG_FUNC(XMLFlow::getThreadId)
        return m_uiThreadId;
    }

    //_____________________________________________________________________
    //  GETENCODING
    //---------------------------------------------------------------------
    const char* XMLFlowContext::getEncoding () const
    {
        DEBUG_FUNC(XMLFlow::getEncoding)
        return exportCharBuffer( m_pszEncoding);
    }


    //_____________________________________________________________________
    //  GETTRANSCODER
    //---------------------------------------------------------------------
    XMLTranscoder* XMLFlowContext::getTranscoder() const
    {
        DEBUG_FUNC(XMLFlow::getEncoding)
        return m_fXCoder;
    }


// ERROR

    //_____________________________________________________________________
    //  GETERROR
    //--------------------------------------------------------------------- 
    unsigned int XMLFlowContext::getError() const
    {
        DEBUG_FUNC(XMLFlow::getError)
        return m_uiErrorNumber;
    }



//  PARAMETERS 
    
    //_________________________________________________________________________
    //  ADDPARAMETER
    //-------------------------------------------------------------------------
    void XMLFlowContext::addParameter ( const char* p_pszName, const char* p_pszValue)
    {
        DEBUG_FUNC(XMLFlow::addParameter)
        m_vaParameters.add( importCharBuffer( m_vaParameters.remove( p_pszName),p_pszValue), p_pszName); 
    }

    //_________________________________________________________________________
    //  GETPARAMETER
    //-------------------------------------------------------------------------
    const char* XMLFlowContext::getParameter ( const char* p_pszName) const
    {
        char*   l_pszValue=0;

        DEBUG_FUNC(XMLFlow::getParameter)

        l_pszValue = m_vaParameters.get( p_pszName);
        if( l_pszValue)
        {
            if(strlen(l_pszValue)>0) return exportCharBuffer( l_pszValue);
        }

        if(m_pParent) return m_pParent->getParameter( p_pszName);
        else return exportCharBuffer("");   
    }


    //_________________________________________________________________________
    //  REMOVEPARAMETER
    //-------------------------------------------------------------------------
    const char* XMLFlowContext::removeParameter ( const char* p_pszName) 
    {
        DEBUG_FUNC(XMLFlow::getParameter)

        return m_vaParameters.remove( p_pszName);
    }


//  BUFFERS  

    //_________________________________________________________________________
    //  ADDNAMEDBUFFER
    //-------------------------------------------------------------------------
    void XMLFlowContext::addNamedBuffer( const char* p_pszName, XMLStreamBuffer* p_pXMLStreamBuffer)
    {
        //---------------------------------------------------------------------
        XMLStreamBuffer* l_pOldBuffer=0;
        //---------------------------------------------------------------------

        DEBUG_FUNC(XMLFlow::addNamedBuffer)

        delete( m_vaNamedBuffers.remove( p_pszName));
        m_vaNamedBuffers.add( p_pXMLStreamBuffer, p_pszName);
    }

    //_________________________________________________________________________
    //  GETNAMEDBUFFER
    //-------------------------------------------------------------------------
    XMLStreamBuffer* XMLFlowContext::getNamedBuffer( const char* p_pszName) const
    {
        XMLStreamBuffer*    l_pBuffer;
        DEBUG_FUNC(XMLFlow::getNamedBuffer)
        
        l_pBuffer = m_vaNamedBuffers.get( p_pszName);
        if( l_pBuffer) return l_pBuffer;
        else 
        {
            if(m_pParent) return m_pParent->getNamedBuffer(p_pszName);
            else return 0;
        }
    }

    //_________________________________________________________________________
    //  GETNAMEDBUFFER
    //-------------------------------------------------------------------------
    XMLStreamBuffer* XMLFlowContext::removeNamedBuffer( const char* p_pszName) 
    {
        DEBUG_FUNC(XMLFlow::getNamedBuffer)
        
        return m_vaNamedBuffers.remove( p_pszName);
    }

// RELEASERS

    //_____________________________________________________________________
    //  RELEASEBUFFERS
    //---------------------------------------------------------------------
    void XMLFlowContext::releaseBuffers()
    {
        //-----------------------------------------------------------------
        XMLStreamBuffer*        l_pXMLStreamBuffer;
        //-----------------------------------------------------------------

        DEBUG_FUNC(XMLFlow::releaseBuffers)

        // Release buffers map;
        while( !m_vaNamedBuffers.empty() )
        {
            l_pXMLStreamBuffer = m_vaNamedBuffers.pop();
            //l_pXMLStreamBuffer->flush();
            delete l_pXMLStreamBuffer;  
        }
    }

    //_____________________________________________________________________
    //  RELEASEPARAMETERS
    //---------------------------------------------------------------------
    void XMLFlowContext::releaseParameters()
    {
        DEBUG_FUNC(XMLFlow::releaseParameters)
        while( !m_vaParameters.empty() ) releaseCharBuffer( m_vaParameters.pop());  
    }


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

END_XDFLENGINE_NS

---