---

valuesstreamer.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  VALUESHANDLER.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 "valuesstreamer.hpp"
#   include "flow/consumers/streamsax2parser.hpp"
#   include "processor/xmlflowcontext.hpp"
#   include "streamers/generic/saxstreamer.hpp"

BEGIN_XDFLENGINE_NS


//=============================================================================
//  CLASS ValuesStreamerFactory
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    XMLStreamer* ValuesStreamerFactory::getStreamer(
        StreamerParams*         p_pParameters, 
        XMLFlowContext* p_pStreamContext, 
        XMLStreamConsumer*      p_pStreamConsumer) const
    {
        //---------------------------------------------------------------------
        SAXValuesHandler*   l_pSaxRawHandler;
        //---------------------------------------------------------------------

        l_pSaxRawHandler = new SAXValuesHandler( p_pParameters, p_pStreamContext);
        return (XMLStreamer*) new SaxStreamer( this, p_pParameters, p_pStreamContext, p_pStreamConsumer, l_pSaxRawHandler, true);
    }

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

//=============================================================================
//  CLASS _ValuesStreamerFactory
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    XMLStreamer* _ValuesStreamerFactory::getStreamer(
        StreamerParams*         p_pParameters, 
        XMLFlowContext* p_pStreamContext, 
        XMLStreamConsumer*      p_pStreamConsumer) const
    {
        //---------------------------------------------------------------------
        SAXValuesHandler*   l_pSaxRawHandler;
        //---------------------------------------------------------------------

        l_pSaxRawHandler = new SAXValuesHandler( p_pParameters, (XMLFlowContext*) p_pStreamContext->getParent());
        return (XMLStreamer*) new SaxStreamer( this, p_pParameters, p_pStreamContext, p_pStreamConsumer, l_pSaxRawHandler, true);
    }

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



//=============================================================================
//  CLASS SAXVALUESHANDLER
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    //_________________________________________________________________________
    //  SAXVALUESHANDLER
    //-------------------------------------------------------------------------
    SAXValuesHandler::SAXValuesHandler( StreamerParams* p_pParameters,XMLFlowContext*   p_pContext)
    {   
        //---------------------------------------------------------------------
        const char*     l_pszFilter;
        //---------------------------------------------------------------------

        // init properties
        m_fValues=false;
        if ( strcmp( XMLStreamer::getParamValue( p_pParameters, VALUESSTREAMER_VALUES, VALUESSTREAMER_VALUES_DEF ) , REQ_TRUE ) == 0 ) m_fValues=true;
        m_fCount=false;
        if ( strcmp( XMLStreamer::getParamValue( p_pParameters, VALUESSTREAMER_COUNT, VALUESSTREAMER_COUNT_DEF) , REQ_TRUE ) == 0 ) m_fCount=true;
        m_fList=false;
        if ( strcmp( XMLStreamer::getParamValue( p_pParameters, VALUESSTREAMER_LIST, VALUESSTREAMER_LIST_DEF) , REQ_TRUE ) == 0 ) m_fList=true;
        
        m_pszSep = importCharBuffer(0, XMLStreamer::getParamValue( p_pParameters,VALUESSTREAMER_SEP,VALUESSTREAMER_SEP_DEF));

        m_pszFilter = 0;
        l_pszFilter = XMLStreamer::getParamValue( p_pParameters,VALUESSTREAMER_FILTER,VALUESSTREAMER_FILTER_DEF);
        if ( strlen( l_pszFilter) > 0)
        {
            m_pszFilter = concatCharBuffer( 0, VALUESSTREAMER_FILTERSEP);
            m_pszFilter = concatCharBuffer( m_pszFilter, l_pszFilter);
            m_pszFilter = concatCharBuffer( m_pszFilter, VALUESSTREAMER_FILTERSEP);
        }

        m_pContext = p_pContext;

        DEBUG_CREATE(SAXValuesHandler)
    }

    //_________________________________________________________________________
    //  ~SAXVALUESHANDLER
    //-------------------------------------------------------------------------
    SAXValuesHandler::~SAXValuesHandler()
    {
        //---------------------------------------------------------------------
        char* l_pszBuffer = 0;
        //---------------------------------------------------------------------

        DEBUG_DEL(SAXValuesHandler)

        m_pszFilter = releaseCharBuffer( m_pszFilter);
        m_pszSep = releaseCharBuffer( m_pszSep);
        while(!m_vaValues.empty()) releaseCharBuffer( m_vaValues.pop());
    }


    //  CONTENTHANDLER  

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

        DEBUG_IN(SAXValuesHandler::characters)

        l_pszChars = XSTR( m_pContext->getTranscoder(), chars, length);
        l_pszTrimmedChars = trimCharBuffer(l_pszChars);
        releaseCharBuffer( l_pszChars);
         
        if(( strlen( l_pszTrimmedChars) > 0 ) && (! m_vaValues.empty() )) 
        {
            l_pszName = copyCharBuffer( m_vaValues.getKey( m_vaValues.size() -1));
            l_pszValue = m_vaValues.top();
            m_vaValues.pop();
            
            l_pszValue = concatCharBuffer( l_pszValue, l_pszTrimmedChars);          
            m_vaValues.add(l_pszValue, l_pszName);
            l_pszName = releaseCharBuffer( l_pszName);
        }

        l_pszTrimmedChars = releaseCharBuffer( l_pszTrimmedChars);

        DEBUG_OUT(SAXValuesHandler::characters)
    }

    //_________________________________________________________________________
    //  STARTELEMENT
    //-------------------------------------------------------------------------
    void SAXValuesHandler::startElement(  const XMLCh* const uri,    const XMLCh* const localname,   const XMLCh* const qname, const Attributes& attrs)
    {
        char*   l_pszValName = 0;
        char    l_szTagName[XMLPROCESSOR_MAX_TAG_SIZE];

        DEBUG_IN(SAXValuesHandler::startElement)

        XSTR(m_pContext->getTranscoder(), localname, (char*) &l_szTagName);

        l_pszValName = 0;
        if(! m_vaValues.empty())
        {
            l_pszValName = copyCharBuffer( m_vaValues.getKey( m_vaValues.size() -1));
            l_pszValName = concatCharBuffer( l_pszValName, VALUESSTREAMER_VALSEP);
        }

        l_pszValName = concatCharBuffer( l_pszValName, (char*) &l_szTagName);

        m_vaValues.add( copyCharBuffer(""), l_pszValName);
        releaseCharBuffer( l_pszValName);

        DEBUG_OUT(SAXValuesHandler::startElement)
    }

    //_________________________________________________________________________
    //  ENDELEMENT
    //-------------------------------------------------------------------------
    void SAXValuesHandler::endElement(  const XMLCh* const uri,  const XMLCh* const localname,   const XMLCh* const qname)
    {
        //---------------------------------------------------------------------
        char*           l_pszName = 0;
        char*           l_pszEnclosedName = 0;
        char*           l_pszValue = 0;
        char*           l_pszListParam = 0;
        char*           l_pszNameCount = 0;
        const char*     l_pszParam = 0;
        char            l_cCount[50];
        unsigned int    l_uiCount = 0;
        //---------------------------------------------------------------------

        DEBUG_IN(SAXValuesHandler::endElement)

        if( !m_vaValues.empty()) 
        {   
            l_pszName = copyCharBuffer(m_vaValues.getKey( m_vaValues.size() -1));
            l_pszValue = m_vaValues.pop();  

            if(strlen(l_pszValue)>0)
            {
                // Enclose name with filter seps
                l_pszEnclosedName = copyCharBuffer( VALUESSTREAMER_FILTERSEP);
                l_pszEnclosedName = concatCharBuffer( l_pszEnclosedName, l_pszName);
                l_pszEnclosedName = concatCharBuffer( l_pszEnclosedName, VALUESSTREAMER_FILTERSEP);
                
                // test filter
                if( ( ! m_pszFilter ) || ( strstr( m_pszFilter, l_pszEnclosedName) ) )
                { 
                    if(m_fValues)
                    {                   
                        if(m_fList)
                        {
                            l_pszParam = m_pContext->getParameter(l_pszName);
                            if( strlen( l_pszParam) == 0 )
                            {
                                m_pContext->addParameter(l_pszName, l_pszValue);
                            }
                            else
                            {
                                l_pszListParam = copyCharBuffer( l_pszParam);
                                l_pszListParam = concatCharBuffer( l_pszListParam, m_pszSep);
                                l_pszListParam = concatCharBuffer( l_pszListParam, l_pszValue);
                                m_pContext->addParameter( l_pszName, l_pszListParam);
                            }
                        }
                        else
                        {
                            m_pContext->addParameter( l_pszName, l_pszValue);
                        }
                    }
                    if(m_fCount)
                    {                   
                        l_pszNameCount = copyCharBuffer( l_pszName);
                        l_pszNameCount = concatCharBuffer( l_pszNameCount, VALUESSTREAMER_COUNT_SUFFIX);

                        l_pszParam = m_pContext->getParameter( l_pszNameCount);
                        if( strlen( l_pszParam) == 0 ) l_pszParam = "0";

                        l_uiCount=atoi( l_pszParam);
                        l_uiCount++;
                        sprintf((char*) &l_cCount,"%d", l_uiCount);
                        m_pContext->addParameter( l_pszNameCount, l_cCount);                
                    }
                }
                
                l_pszEnclosedName = releaseCharBuffer( l_pszEnclosedName);          
                l_pszListParam = releaseCharBuffer( l_pszListParam);
                l_pszNameCount = releaseCharBuffer( l_pszNameCount);
            }

            l_pszValue = releaseCharBuffer( l_pszValue);
            l_pszName = releaseCharBuffer( l_pszName);
        }

        DEBUG_OUT(SAXValuesHandler::endElement)
    }

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


END_XDFLENGINE_NS

---