---

langloadstreamer.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 "langloadstreamer.hpp"
#   include "flow/consumers/streamsax2parser.hpp"
#   include "processor/xmlflowcontext.hpp"
#   include "streamers/generic/saxstreamer.hpp"

BEGIN_XDFLENGINE_NS


//=============================================================================
//  CLASS LangLoadStreamerFactory
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_____________________________________________________________________
    //  LangLoadStreamerFactory
    //---------------------------------------------------------------------
    LangLoadStreamerFactory::LangLoadStreamerFactory()
    {
        m_pCurDictionnary = 0;
        m_pCurLangPack = 0;
        m_pszCurLangPack = copyCharBuffer("");
        m_pszCurDictionnary = copyCharBuffer("");
    }

    //_____________________________________________________________________
    //  ~LangLoadStreamerFactory
    //---------------------------------------------------------------------
    LangLoadStreamerFactory::~LangLoadStreamerFactory()
    {
        VAlangPack *        l_pLangPack = 0;
        VAdictionnary *     l_pDictionnary = 0;

        while(!m_vaLangPacks.empty())
        {
            l_pLangPack = m_vaLangPacks.pop();
            while(! l_pLangPack->empty())
            {
                l_pDictionnary = l_pLangPack->pop();
                while(! l_pDictionnary->empty()) releaseCharBuffer( l_pDictionnary->pop());
                delete l_pDictionnary;
            }
            delete l_pLangPack;
        }

        m_pszCurLangPack = releaseCharBuffer(m_pszCurLangPack);
        m_pszCurDictionnary = releaseCharBuffer(m_pszCurDictionnary);

    }


    //_____________________________________________________________________
    //  ~getStreamer
    //---------------------------------------------------------------------
    XMLStreamer* LangLoadStreamerFactory::getStreamer(
        StreamerParams*         p_pParameters, 
        XMLFlowContext*         p_pStreamContext, 
        XMLStreamConsumer*      p_pStreamConsumer) const
    {
        //---------------------------------------------------------------------
        SAXLangHandler* l_pSaxRawHandler;
        //---------------------------------------------------------------------

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



    //_____________________________________________________________________
    //  setDictionnaryEntry
    //---------------------------------------------------------------------
    void LangLoadStreamerFactory::setDictionnaryEntry( const char* p_pszLangCode, const char* p_pszDicName, const char* p_pszKey, char* p_pszWord)
    {
        
        if( strcmp( m_pszCurLangPack, p_pszLangCode) != 0 )
        {
            // language pack requested is not last accessed : get the requested language pack
            m_pCurLangPack = m_vaLangPacks.get( p_pszLangCode);

            if( !m_pCurLangPack)
            {
                //create new language pack
                m_pCurLangPack = new VAlangPack;
                m_vaLangPacks.add( m_pCurLangPack, p_pszLangCode);
            }

            m_pszCurLangPack = importCharBuffer( m_pszCurLangPack,p_pszLangCode);
            m_pszCurDictionnary = importCharBuffer( m_pszCurDictionnary,"");
            m_pCurDictionnary = 0;

        }

        if( strcmp( m_pszCurDictionnary, p_pszDicName) != 0 )
        {
            // dictionnary requested is not last accessed : get the requested dictionnary
            m_pCurDictionnary = m_pCurLangPack->get( p_pszDicName);

            if( !m_pCurDictionnary)
            {
                //create new dictionnary
                m_pCurDictionnary = new VAdictionnary;
                m_pCurLangPack->add( m_pCurDictionnary, p_pszDicName);
                logout << "\t" << LANGLOADSTREAMER_TAGNAME<< "   :   " << "Loading "<< m_pszCurLangPack << "." << p_pszDicName << " language dictionnary.\n";
            }

            m_pszCurDictionnary = importCharBuffer( m_pszCurDictionnary,p_pszDicName);

        }

        m_pCurDictionnary->add( copyCharBuffer(p_pszWord), p_pszKey);
    }

    //_____________________________________________________________________
    //  getDictionnaryEntry
    //---------------------------------------------------------------------
    const char* LangLoadStreamerFactory::getDictionnaryEntry( const char* p_pszLangCode, const char* p_pszDicName, const char* p_pszKey) const
    {
        VAlangPack *        l_pLangPack = 0;
        VAdictionnary *     l_pDictionnary = 0;
        const char*         l_pszValue = 0;

        l_pLangPack = m_vaLangPacks.get( p_pszLangCode);
        if( l_pLangPack) l_pDictionnary = l_pLangPack->get( p_pszDicName);
        if( l_pDictionnary ) l_pszValue = l_pDictionnary->get( p_pszKey);
        if(l_pszValue) return l_pszValue;
        else return "";
    }

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





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


    //_________________________________________________________________________
    //  SAXVALUESHANDLER
    //-------------------------------------------------------------------------
    SAXLangHandler::SAXLangHandler( StreamerParams* p_pParameters,XMLFlowContext*   p_pContext, const LangLoadStreamerFactory* p_pParent)
    {   

        m_pContext = p_pContext;
        m_intCurLevel = 0;
        m_pParent = (LangLoadStreamerFactory*) p_pParent;
        m_pszCurLangPack=0;
        m_pszCurDictionnary=0;

        DEBUG_CREATE(SAXLangHandler)
    }

    //_________________________________________________________________________
    //  ~SAXVALUESHANDLER
    //-------------------------------------------------------------------------
    SAXLangHandler::~SAXLangHandler()
    {

        DEBUG_DEL(SAXLangHandler)
        m_pszCurLangPack=releaseCharBuffer( m_pszCurLangPack);
        m_pszCurDictionnary=releaseCharBuffer( m_pszCurDictionnary);
        while(!m_vaValues.empty()) releaseCharBuffer( m_vaValues.pop());
    }


    //  CONTENTHANDLER  

    //_________________________________________________________________________
    //  CHARACTERS
    //-------------------------------------------------------------------------
    void SAXLangHandler::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(SAXLangHandler::characters)

        if(m_intCurLevel>3)
        {
            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(SAXLangHandler::characters)
    }

    //_________________________________________________________________________
    //  STARTELEMENT
    //-------------------------------------------------------------------------
    void SAXLangHandler::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];

        m_intCurLevel++;

        DEBUG_IN(SAXLangHandler::startElement)

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

        if(m_intCurLevel==2) m_pszCurLangPack = importCharBuffer(m_pszCurLangPack, l_szTagName);
        if(m_intCurLevel==3) m_pszCurDictionnary = importCharBuffer(m_pszCurDictionnary, l_szTagName);
        if(m_intCurLevel>3)
        {
            l_pszValName = 0;
            if(! m_vaValues.empty())
            {
                l_pszValName = copyCharBuffer( m_vaValues.getKey( m_vaValues.size() -1));
                l_pszValName = concatCharBuffer( l_pszValName, LANGLOADSTREAMER_VALSEP);
            }

            l_pszValName = concatCharBuffer( l_pszValName, (char*) &l_szTagName);
            m_vaValues.add( copyCharBuffer(""), l_pszValName);
            releaseCharBuffer( l_pszValName);
        }

        DEBUG_OUT(SAXLangHandler::startElement)
    }

    //_________________________________________________________________________
    //  ENDELEMENT
    //-------------------------------------------------------------------------
    void SAXLangHandler::endElement(  const XMLCh* const uri,    const XMLCh* const localname,   const XMLCh* const qname)
    {
        //---------------------------------------------------------------------
        char*           l_pszName = 0;
        char*           l_pszValue = 0;
        //---------------------------------------------------------------------

        DEBUG_IN(SAXLangHandler::endElement)

        if(m_intCurLevel>3)
        {
            if( !m_vaValues.empty()) 
            {   
                l_pszName = copyCharBuffer(m_vaValues.getKey( m_vaValues.size() -1));
                l_pszValue = m_vaValues.pop();          
                if(strlen(l_pszValue)>0)
                {
                    m_pParent->setDictionnaryEntry( m_pszCurLangPack, m_pszCurDictionnary, l_pszName, l_pszValue);
                }
                l_pszName = releaseCharBuffer( l_pszName);
                l_pszValue = releaseCharBuffer( l_pszValue);
            }
        }

        m_intCurLevel--;

        DEBUG_OUT(SAXLangHandler::endElement)
    }

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


END_XDFLENGINE_NS

---