---

xmlflow.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//----------------------------------------------------------------------------- 
//  XMLFLOW.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 "xmlflow.hpp"
#include "processor/xmlstreamer.hpp"
#include "processor/xmlflowcontext.hpp"
#include "flow/consumers/nullconsumer.hpp"

BEGIN_XDFLENGINE_NS


//============================================================================= 
//  CLASS PassiveStreamNode
//----------------------------------------------------------------------------- 

    //_____________________________________________________________________
    //  PassiveStreamNode
    //---------------------------------------------------------------------
    PassiveStreamNode::PassiveStreamNode()
    {
        DEBUG_CREATE(PassiveStreamNode)
    }

    //_____________________________________________________________________
    //  ~PassiveStreamNode
    //---------------------------------------------------------------------
    PassiveStreamNode::~PassiveStreamNode()
    {
        DEBUG_DEL(PassiveStreamNode)
    }

    //_____________________________________________________________________
    //  streamXML
    //---------------------------------------------------------------------
    void PassiveStreamNode::streamXML(XMLStreamConsumer* p_pStreamConsumer, XMLFlowContext* p_pStreamContext) const
    {
        //-----------------------------------------------------------------
        char*   l_pszValuatedChunk=0;
        //-----------------------------------------------------------------

        DEBUG_FUNC(PassiveStreamNode::streamXML)

        PREP_CATCH_XML_FLOW_ERROR;

        // !! calcul des valeurs parsées
        if(MemBuffer::length()>0)
        {
            WATCH_XML_FLOW_ERROR
            {
                l_pszValuatedChunk=p_pStreamContext->calculateValue( MemBuffer::data());
                (*p_pStreamConsumer) << l_pszValuatedChunk;
            } 
            CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN         
        }

    RELEASE_AND_RETURN:
        l_pszValuatedChunk = releaseCharBuffer( l_pszValuatedChunk);
        ON_XML_FLOW_ERROR_THROW;
    }

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





//============================================================================= 
//  CLASS ActiveStreamNode
//----------------------------------------------------------------------------- 

    
    //_____________________________________________________________________
    //  ActiveStreamNode
    //--------------------------------------------------------------------- 
    ActiveStreamNode::ActiveStreamNode(XMLStreamerFactory* p_pStreamerFactory, StreamerParams*  p_pStreamerParams)
    {
        DEBUG_CREATE(ActiveStreamNode)
        m_pStreamerFactory = p_pStreamerFactory;
        m_pStreamerParams = p_pStreamerParams;
    }

    //_____________________________________________________________________
    //  ~ActiveStreamNode
    //---------------------------------------------------------------------
    ActiveStreamNode::~ActiveStreamNode()
    {
        DEBUG_DEL(ActiveStreamNode)
        if(m_pStreamerParams)
        {
            while( ! m_pStreamerParams->empty())releaseCharBuffer(m_pStreamerParams->pop()); 
            delete m_pStreamerParams;
        }
        while( ! m_vaChildStreamNodes.empty()) delete m_vaChildStreamNodes.pop();
    }

    //_____________________________________________________________________
    //  getParams
    //---------------------------------------------------------------------
    StreamerParams* ActiveStreamNode::getParams()
    {
        return m_pStreamerParams;
    }

    //_____________________________________________________________________
    //  appendChild
    //---------------------------------------------------------------------
    void ActiveStreamNode::appendChild(XMLFlowNode* p_pChildStreamNode)
    {
        DEBUG_FUNC(ActiveStreamNode::appendChild)
        m_vaChildStreamNodes.push( p_pChildStreamNode);
    }

    //_____________________________________________________________________
    //  streamXML
    //---------------------------------------------------------------------
    void ActiveStreamNode::streamXML(XMLStreamConsumer* p_pStreamConsumer, XMLFlowContext* p_pStreamContext) const
    {
        //-----------------------------------------------------------------
        XMLFlowNode*        l_pStreamNode;
        XMLStreamer*        l_pXMLStreamer=0;
        XMLStreamConsumer*  l_pXMLConsumer=0;
        XMLStreamConsumer*  l_pErrorOutput=0;
        NullConsumer*       l_pNullConsumer=0;
        unsigned int        i;
        const char*         l_pszEnclose;
        const char*         l_pszOutput;
        const char*         l_pszComment;
        StreamerParams*     l_pszValuatedParams=0;
        bool                l_fErrorFatal;
        bool                l_fStreamerInitOK;
        bool                l_fEncloseCDATA;
        //-----------------------------------------------------------------

        PREP_CATCH_XML_FLOW_ERROR;

        DEBUG_FUNC(ActiveStreamNode::streamXML)

        // get general streamer parameters

        // valuate parameters collection
        l_pszValuatedParams = valuateParameters( p_pStreamContext, m_pStreamerParams);

        // ? error fatal
        l_fErrorFatal = true;
        if( strcmp( XMLStreamer::getParamValue(l_pszValuatedParams, REQ_ERRFATAL, REQ_ERRFATAL_DEF), REQ_FALSE) == 0 ) l_fErrorFatal = false;

        // errors output
        l_pErrorOutput = 0;
        l_pszOutput = XMLStreamer::getParamValue( l_pszValuatedParams, REQ_OUTPUTERROR, REQ_OUTPUTERROR_DEF);
        if( strcmp( l_pszOutput, REQ_PARENTOUTPUT) == 0) l_pErrorOutput = p_pStreamConsumer;
        if( strcmp( l_pszOutput, REQ_NOOUTPUT) == 0)
        {
            if(!l_pNullConsumer) l_pNullConsumer =  new NullConsumer;
            l_pErrorOutput = l_pNullConsumer;
        }
        if( !l_pErrorOutput )l_pErrorOutput = p_pStreamContext->getNamedBuffer( l_pszOutput);
        if( !l_pErrorOutput ) 
        {
            MAKE_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FLOWBUILDER + ERRCODE_CAUSE_MISSINGREF , "No error buffer was found with that name." , l_pszOutput, "ActiveStreamNode::streamXML", "", false );
            goto RELEASE_AND_RETURN;
        }

        // comment ...
        l_pszComment = XMLStreamer::getParamValue(l_pszValuatedParams, REQ_COMMENT, "");
        if (strlen( l_pszComment)>0) logout << "\n" << l_pszComment << "\n\n";

        // enclose tag
        l_pszEnclose = XMLStreamer::getParamValue( l_pszValuatedParams, REQ_ENCLOSE, REQ_ENCLOSE_DEF);
        if(strlen(l_pszEnclose)==0) l_pszEnclose = 0;

        // enclose CDATA
        l_fEncloseCDATA = false;
        if( strcmp( XMLStreamer::getParamValue(l_pszValuatedParams, REQ_ENCLOSECDATA, REQ_ENCLOSECDATA_DEF), REQ_TRUE) == 0 ) l_fEncloseCDATA = true;
    
        // output 
        l_pXMLConsumer = 0;
        l_pszOutput = XMLStreamer::getParamValue(l_pszValuatedParams, REQ_OUTPUT, REQ_OUTPUT_DEF);
        if( strcmp( l_pszOutput, REQ_PARENTOUTPUT) == 0) l_pXMLConsumer = p_pStreamConsumer;
        if( strcmp( l_pszOutput, REQ_NOOUTPUT) == 0)
        {
            if(!l_pNullConsumer) l_pNullConsumer =  new NullConsumer;
            l_pXMLConsumer = l_pNullConsumer;
        }
        if( !l_pXMLConsumer ) l_pXMLConsumer = p_pStreamContext->getNamedBuffer( l_pszOutput);
        if( !l_pXMLConsumer )
        {
            MAKE_XMLFLOW_EXCEPTION ( ERRCODE_LOC_FLOWBUILDER + ERRCODE_CAUSE_MISSINGREF , "No output buffer was found with that name." , l_pszOutput, "ActiveStreamNode::streamXML", "", false );
            goto RELEASE_AND_RETURN;
        }
        
        // create streamer object
        l_pXMLStreamer = m_pStreamerFactory->getStreamer( l_pszValuatedParams, p_pStreamContext,  l_pXMLConsumer);
        
        if(l_pszEnclose)  (*p_pStreamConsumer) << "<" << l_pszEnclose << ">\n";
        if(l_fEncloseCDATA) (*p_pStreamConsumer) << "<![CDATA[";

        // process all children into current streamer
        WATCH_XML_FLOW_ERROR
        {
            l_fStreamerInitOK = l_pXMLStreamer->initStream();
            if ( l_fStreamerInitOK ) // init ...
            {
                for(i=0; i < m_vaChildStreamNodes.size(); i++) 
                {
                    l_pStreamNode = m_vaChildStreamNodes.get(i);                    
                    l_pStreamNode->streamXML( l_pXMLStreamer, p_pStreamContext);
                }
                l_pXMLStreamer->commitStream(true);
                // .. and commit
            }

        } 
        CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN

        if(l_fEncloseCDATA) (*p_pStreamConsumer) << "]]>";
        if(l_pszEnclose)  (*p_pStreamConsumer) << "</" << l_pszEnclose << ">\n";

    RELEASE_AND_RETURN:

        ON_XML_FLOW_ERROR_DO
        {
            if(l_pErrorOutput) (*l_pXMLFlowException) >> (*l_pErrorOutput);
        }

        if(l_pNullConsumer) delete l_pNullConsumer;
        if(l_pszValuatedParams) 
        {
            while( !l_pszValuatedParams->empty() ) releaseCharBuffer( l_pszValuatedParams->pop());
            delete l_pszValuatedParams;
        }
        delete l_pXMLStreamer;

        ON_XML_FLOW_ERROR_DO
        {
            if( l_fErrorFatal) throw l_pXMLFlowException;
            else delete l_pXMLFlowException;                
        }
    }

    //_____________________________________________________________________
    //  valuateParameters
    //---------------------------------------------------------------------
    StreamerParams* ActiveStreamNode::valuateParameters(XMLFlowContext* p_pStreamContext,const StreamerParams* p_pStreamerParams) const
    {
        //-----------------------------------------------------------------
        unsigned int    l_uiSize;
        unsigned int    i;
        char*           l_pszValue;
        char*           l_pszCalculatedValue;
        const char*     l_pszKey;
        StreamerParams* l_pszValuatedParams;
        //-----------------------------------------------------------------


        l_pszValuatedParams = new StreamerParams;
        l_uiSize=p_pStreamerParams->size();
        for(i=0 ; i< l_uiSize; i++)
        {
            l_pszKey = p_pStreamerParams->getKey(i);
            l_pszValue = p_pStreamerParams->get(i);
            l_pszCalculatedValue = p_pStreamContext->calculateValue( l_pszValue);
            l_pszValuatedParams->add( l_pszCalculatedValue, l_pszKey);
        }

        return l_pszValuatedParams;

    }

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

//============================================================================= 
//  CLASS RootStreamNode
//----------------------------------------------------------------------------- 


    //_____________________________________________________________________
    //  RootStreamNode
    //---------------------------------------------------------------------
    RootStreamNode::RootStreamNode():ActiveStreamNode(0,0)
    {
        DEBUG_CREATE(RootStreamNode)
    }

    //_____________________________________________________________________
    //  RootStreamNode
    //---------------------------------------------------------------------
    RootStreamNode::~RootStreamNode()
    {
        DEBUG_DEL(RootStreamNode)
    }


    //_____________________________________________________________________
    //  streamXML
    //---------------------------------------------------------------------
    void RootStreamNode::streamXML( XMLStreamConsumer* p_pStreamConsumer, XMLFlowContext* p_pStreamContext) const
    {
        //-----------------------------------------------------------------
        XMLFlowNode* l_pStreamNode;
        unsigned int        i;
        //-----------------------------------------------------------------

        PREP_CATCH_XML_FLOW_ERROR;

        DEBUG_FUNC(RootStreamNode::streamXML)

        WATCH_XML_FLOW_ERROR
        { 
            for(i=0; i < m_vaChildStreamNodes.size(); i++)
            {
                l_pStreamNode = m_vaChildStreamNodes.get(i);
                l_pStreamNode->streamXML( p_pStreamConsumer, p_pStreamContext);
            }

        } 
        CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN

    RELEASE_AND_RETURN:

        ON_XML_FLOW_ERROR_THROW;
    }

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

END_XDFLENGINE_NS

---