---

xmlflowbuilder.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  XMLFLOWBUILDER.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 "xmlflowbuilder.hpp"
#   include "processor/xmlprocessor.hpp"

BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS XMLFlowBuilder
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


//  CONSTRUCTORS AND DESTRUCTOR  

    //_________________________________________________________________________
    //  XMLFlowBuilder
    //-------------------------------------------------------------------------
    XMLFlowBuilder::XMLFlowBuilder(  const XMLProcessor* p_pXMLProcessor, RootStreamNode* p_pStreamRoot,  const char* p_pszActiveURI)
    :SAX2Formatter(p_pXMLProcessor->getContext()->getEncoding(), XMLFormatter::UnRep_CharRef,false, 0)
    {   
        m_uiErrorNumber = 0;
        m_uiCurDepth = 0;
        m_fTopStreamerPassive=false;

        m_pXMLProcessor = p_pXMLProcessor;  
        m_pszActiveURI = importCharBuffer(0, p_pszActiveURI);

        m_vaStackStreamNodes.push( p_pStreamRoot);

        DEBUG_CREATE(XMLFlowBuilder)
    }

    //_________________________________________________________________________
    //  ~XMLFlowBuilder
    //-------------------------------------------------------------------------
    XMLFlowBuilder::~XMLFlowBuilder()
    {       
        DEBUG_DEL(XMLFlowBuilder)

        m_pszActiveURI = releaseCharBuffer(m_pszActiveURI);
        while( ! m_vaStackStreamNodes.empty() ) m_vaStackStreamNodes.pop();     
    }


// ERROR

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


//  CONTENTHANDLER  

    //_________________________________________________________________________
    // STARTELEMENT
    //-------------------------------------------------------------------------
    void XMLFlowBuilder::startElement(  const XMLCh* const uri, 
                                            const XMLCh* const localname, 
                                            const XMLCh* const qname, 
                                            const Attributes& attrs)
    {
        //---------------------------------------------------------------------
        StreamerParams*  l_pParameters;

        char*           l_pszFullName=0;
        char*           l_pszTagName=0;
        char*           l_pszURI=0;
        char*           l_pszAttr=0;
        char*           l_pszValue=0;
        char*           l_pszTmp=0;

        unsigned int    l_uiAttrsCount;
        unsigned int    i;
        unsigned int    j;

        ActiveStreamNode*   l_pParentStreamNode = 0;
        ActiveStreamNode*   l_pActiveStreamNode = 0;
        PassiveStreamNode*  l_pPassiveStreamNode = 0;

        XMLStreamerFactory* l_pStreamerFactory = 0;
        //---------------------------------------------------------------------

        DEBUG_IN(XMLFlowBuilder::startElement)

        PREP_CATCH_XML_FLOW_ERROR;

        m_uiCurDepth++;

        l_pszTagName = XSTR(m_pXMLProcessor->getContext()->getTranscoder(), localname);
        l_pszFullName = XSTR(m_pXMLProcessor->getContext()->getTranscoder(), qname);
        l_pszURI = XSTR(m_pXMLProcessor->getContext()->getTranscoder(), uri);       

        DEBUG_ECHO <<  l_pszTagName << " " << m_uiCurDepth << "(+)\n";


        // Choose what to do depending on the tag's name
        if( strcmp( l_pszURI, m_pszActiveURI) == 0 ) 
        {
            if(m_fTopStreamerPassive) m_vaStackStreamNodes.pop();
            m_fTopStreamerPassive=false;

            l_pParentStreamNode = (ActiveStreamNode*)m_vaStackStreamNodes.top();

            logout << "\t";
            for(j=1; j<m_vaStackStreamNodes.size(); j++) logout<< "  ";
            logout << l_pszTagName << "\n";

            // make params collection               
            l_pParameters = new StreamerParams;
            l_uiAttrsCount = attrs.getLength();
            for (i=0 ; i< l_uiAttrsCount ; i++)
            {
                l_pszAttr = XSTR(m_pXMLProcessor->getContext()->getTranscoder(), attrs.getLocalName( i));
                l_pszValue = XSTR(m_pXMLProcessor->getContext()->getTranscoder(), attrs.getValue( i));                  

                logout<< "\t";
                for(j=1; j<m_vaStackStreamNodes.size(); j++) logout<< "  ";
                logout << "   | ";
                logout << l_pszAttr << " : " << l_pszValue << "\n";
                
                l_pParameters->add( l_pszValue, l_pszAttr);
                
                //l_pszValue = releaseCharBuffer( l_pszValue);  
                l_pszAttr  = releaseCharBuffer( l_pszAttr);
            }
            logout << "\n";

            // create new active streamer node
            l_pStreamerFactory = m_pXMLProcessor->getStreamerFactory( l_pszTagName);
            if(! l_pStreamerFactory)
            {
                MAKE_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FLOWBUILDER + ERRCODE_CAUSE_MISSINGREF , "Unknown StreamerFactory Tag." , l_pszTagName, "XMLFlowBuilder::startElement", "", false );
                goto RELEASE_AND_RETURN;
            }


            l_pActiveStreamNode =  new ActiveStreamNode( l_pStreamerFactory,l_pParameters);
            l_pParentStreamNode->appendChild( l_pActiveStreamNode);
            m_vaStackStreamNodes.push( l_pActiveStreamNode);
            DEBUG_ECHO << "active node compiled.\n";
        }
        else
        {
            l_pParentStreamNode = (ActiveStreamNode*)m_vaStackStreamNodes.top();

            if(! m_fTopStreamerPassive)
            { 
                l_pPassiveStreamNode = new PassiveStreamNode();
                l_pParentStreamNode->appendChild( l_pPassiveStreamNode);
                m_vaStackStreamNodes.push( l_pPassiveStreamNode);
                m_fTopStreamerPassive=true;
            }
            
            SAX2Formatter::startElement(uri,localname,qname,attrs);
        }
        
        RELEASE_AND_RETURN:

        // Release
        l_pszURI = releaseCharBuffer( l_pszURI);
        l_pszFullName = releaseCharBuffer( l_pszFullName);
        l_pszTagName = releaseCharBuffer( l_pszTagName);

        ON_XML_FLOW_ERROR_DO
        {
            while(! l_pParameters->empty()) releaseCharBuffer( l_pParameters->pop());
            delete l_pParameters;
        }

        DEBUG_OUT(XMLFlowBuilder::startElement)

        ON_XML_FLOW_ERROR_THROW;
    }

    //_________________________________________________________________________
    // CHARACTERS
    //-------------------------------------------------------------------------
    void XMLFlowBuilder::characters(    const XMLCh* const chars , 
                                        const unsigned int length)
    {
        //---------------------------------------------------------------------
        char* l_pszChars=0;
        char* l_pszTrimmedChars=0;

        ActiveStreamNode*   l_pParentStreamNode;
        PassiveStreamNode* l_pPassiveStreamNode=0;
        //---------------------------------------------------------------------

        DEBUG_IN(XMLFlowBuilder::characters)

        if(! m_fTopStreamerPassive)
        {
            l_pParentStreamNode = (ActiveStreamNode*)m_vaStackStreamNodes.top();
            l_pPassiveStreamNode = new PassiveStreamNode();
            l_pParentStreamNode->appendChild( l_pPassiveStreamNode);
            m_vaStackStreamNodes.push( l_pPassiveStreamNode);
            m_fTopStreamerPassive=true;
        }           

        SAX2Formatter::characters( chars , length);
        
        DEBUG_OUT(XMLFlowBuilder::characters)           
    }

    //_________________________________________________________________________
    // ENDELEMENT
    //-------------------------------------------------------------------------
    void XMLFlowBuilder::endElement(    const XMLCh* const uri,
                                        const XMLCh* const localname,
                                        const XMLCh* const qname)
    {
        //---------------------------------------------------------------------
        char* l_pszFullName=0;
        char* l_pszURI=0;
        ActiveStreamNode*       l_pParentStreamNode;
        PassiveStreamNode* l_pPassiveStreamNode=0;
        ActiveStreamNode*   l_pActiveStreamNode=0;
        //---------------------------------------------------------------------
        
        DEBUG_IN(XMLFlowBuilder::endElement)
        
        l_pszFullName = XSTR(m_pXMLProcessor->getContext()->getTranscoder(), qname);
        l_pszURI =      XSTR(m_pXMLProcessor->getContext()->getTranscoder(), uri);

        DEBUG_ECHO <<  l_pszFullName << " " << m_uiCurDepth << "(-)\n";   
        

        // Active node ?
        if ( strcmp( l_pszURI, m_pszActiveURI) == 0 )
        {
            if(m_fTopStreamerPassive) m_vaStackStreamNodes.pop();
            m_fTopStreamerPassive=false;

            l_pActiveStreamNode = (ActiveStreamNode*)m_vaStackStreamNodes.pop();
        }
        else
        {
            if(! m_fTopStreamerPassive)
            {
                l_pParentStreamNode = (ActiveStreamNode*)m_vaStackStreamNodes.top();
                l_pPassiveStreamNode = new PassiveStreamNode();
                l_pParentStreamNode->appendChild( l_pPassiveStreamNode);
                m_vaStackStreamNodes.push( l_pPassiveStreamNode);
                m_fTopStreamerPassive=true;
            }

            SAX2Formatter::endElement(uri,localname,qname);
        }

        
        m_uiCurDepth--;

        l_pszURI = releaseCharBuffer( l_pszURI);
        l_pszFullName = releaseCharBuffer( l_pszFullName);

        DEBUG_OUT(XMLFlowBuilder::endElement)
    }


    //_________________________________________________________________________
    // WRITECHARS
    //-------------------------------------------------------------------------
    void XMLFlowBuilder::writeChars(const XMLByte* const toWrite,const unsigned int count,XMLFormatter* const formatter)
    {
        if(m_fTopStreamerPassive)
        {
            setConsumer( (PassiveStreamNode*)m_vaStackStreamNodes.top());
            SAX2Formatter::writeChars(toWrite,count, formatter);
        }
    }


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

END_XDFLENGINE_NS

---