---

xmlprocessor.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//----------------------------------------------------------------------------- 
//  XMLPROCESSOR.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 "xercesc/util/PlatformUtils.hpp"
#   include "xercesc/util/XMLString.hpp"

#   include "xmlprocessor.hpp"
#   include "flow/consumers/streamsax2parser.hpp"
#   include "flow/consumers/nullconsumer.hpp"
#   include "streamers/xmlstreamerfactories.hpp"

BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS XMLPROCESSOR
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// STATICS

    //_________________________________________________________________________
    //  INIT
    //-------------------------------------------------------------------------
    void XMLProcessor::init()
    {
        DEBUG_INIT
        DEBUG_IN(XDFLengine)

        // Display version info 
        logout << "\n_________________________________________________________________________\n";
        logout.display_version( "XDFLengine", XDFLENGINE_NAME, XDFLENGINE_VERSION, "");
        logout << "----------------------------------------------------------------------\n";
        logout.display_version( "XERCES", "Xerces-C++", XERCES_FULLVERSIONSTR, "The Apache Software Foundation");

        // Start Xerces
        XMLPlatformUtils::Initialize();

        // Set default settings 
        setThreadCount( 1);
    }

    //_________________________________________________________________________
    //  TERMINATE
    //-------------------------------------------------------------------------
    void XMLProcessor::terminate()
    {
        // Terminate Xerces
        XMLPlatformUtils::Terminate();

        logout << "_________________________________________________________________________\n";

        DEBUG_OUT(XDFLengine)
        DEBUG_END
    }

// BUFFER 

    //_________________________________________________________________________
    //  GETNEWBUFFER
    //-------------------------------------------------------------------------
    XMLStreamBuffer* XMLProcessor::getNewBuffer(const char* p_pszBufferType ,const char* p_pszFileName, bool p_fReadOnly, unsigned int p_uiBufferSize) 
    {
        //---------------------------------------------------------------------
        XMLStreamBuffer*    l_pXMLStreamBuffer=0;
        //---------------------------------------------------------------------

        DEBUG_FUNC(XMLProcessor::getNewBuffer)

        if( ! p_pszBufferType) p_pszBufferType = XMLPROCESSOR_STRING;
        if( ! p_pszFileName)
        {
            
            if( ! strcmp( p_pszBufferType, XMLPROCESSOR_FILE) )     l_pXMLStreamBuffer= (XMLStreamBuffer*) new FileBuffer();
            if( ! strcmp( p_pszBufferType, XMLPROCESSOR_ZIP) )      l_pXMLStreamBuffer= (XMLStreamBuffer*) new ZipBuffer();
            if( ! strcmp( p_pszBufferType, XMLPROCESSOR_STRING) )   l_pXMLStreamBuffer= (XMLStreamBuffer*) new MemBuffer();
        }
        else
        {
            if( ! strcmp( p_pszBufferType, XMLPROCESSOR_FILE) )     l_pXMLStreamBuffer= (XMLStreamBuffer*) new FileBuffer(  p_pszFileName, p_fReadOnly, p_uiBufferSize);
            if( ! strcmp( p_pszBufferType, XMLPROCESSOR_ZIP) )      l_pXMLStreamBuffer= (XMLStreamBuffer*) new ZipBuffer(   p_pszFileName, p_fReadOnly, p_uiBufferSize);
        }

        if( ! l_pXMLStreamBuffer )  THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_XMLPROCESSOR + ERRCODE_CAUSE_MISSINGREF , "Invalid buffer type." , p_pszBufferType, "ActiveStreamNode::streamXML", "", false );


        return l_pXMLStreamBuffer;
    }


// THREAD COUNT

    //_____________________________________________________________________
    //  SETTHREADCOUNT
    //---------------------------------------------------------------------
    void XMLProcessor::setThreadCount(unsigned int p_uiThreadCount)
    {
        DEBUG_FUNC(XMLProcessor::setThreadCount)
        g_uiMaxThreads = p_uiThreadCount;
    }

    //_____________________________________________________________________
    //  GETTHREADCOUNT
    //---------------------------------------------------------------------
    unsigned int XMLProcessor::getThreadCount()
    {
        DEBUG_FUNC( XMLProcessor::getThreadCount)
        return g_uiMaxThreads;
    }

//  CONSTRUCTOR & DESTRUCTOR

    //_________________________________________________________________________
    //  XMLPROCESSOR
    //-------------------------------------------------------------------------
    XMLProcessor::XMLProcessor()
    {
        // Init pointers
        m_pszActiveURI = 0;

        m_fOwnContext = true;
        m_pContext = new XMLFlowContext(this,0, 0, CHAR_ENCODING_DEFAULT);

        // Set default URI
        setActiveURI( XMLPROCESSOR_ACTIVEURI);
        DEBUG_CREATE(XMLProcessor)
    }

    //_________________________________________________________________________
    //  ~XMLPROCESSOR
    //-------------------------------------------------------------------------
    XMLProcessor::~XMLProcessor()
    {
        DEBUG_DEL(XMLProcessor) 

        // delete streamer factories
        while(! m_vaStreamerFactories.empty()) delete( m_vaStreamerFactories.pop());


        // delete cached scripts
        while(! m_pvaScriptCache.empty()) delete( m_pvaScriptCache.pop());

        // release owned objects
        if(m_fOwnContext) delete m_pContext;
        m_pszActiveURI = releaseCharBuffer( m_pszActiveURI);
            
    }

// ACTIVE URI

    //_________________________________________________________________________
    //  SETACTIVEURI
    //-------------------------------------------------------------------------
    void XMLProcessor::setActiveURI( const char* p_pszActiveURI)
    {
        DEBUG_FUNC(XMLProcessor::setActiveURI)      
        m_pszActiveURI = importCharBuffer( m_pszActiveURI, p_pszActiveURI);
    }

    //_________________________________________________________________________
    //  GETACTIVEURI
    //-------------------------------------------------------------------------
    const char* XMLProcessor::getActiveURI()
    {
        return exportCharBuffer( m_pszActiveURI);
    }

// STREAMERS


    //_________________________________________________________________________
    //  LOADHANDLERS
    //-------------------------------------------------------------------------     
    void XMLProcessor::loadStreamerFactories()
    {
                DEBUG_IN(XMLProcessor::loadStreamerFactories)

        // Add XML Handlers
        addStreamerFactory( new ValuesStreamerFactory,              VALUESSTREAMER_TAGNAME );       
        addStreamerFactory( new NamedBufferSetStreamerFactory,      NAMEDBUFSETSTREAMER_TAGNAME );
        addStreamerFactory( new NamedBufferGetStreamerFactory,      NAMEDBUFGETSTREAMER_TAGNAME );
        addStreamerFactory( new NullStreamerFactory,                NULLSTREAMER_TAGNAME );   
        addStreamerFactory( new RawStreamerFactory,                 RAWSTREAMER_TAGNAME );
        addStreamerFactory( new SystemStreamerFactory,              SYSTEMSTREAMER_TAGNAME );
        addStreamerFactory( new RaiseErrorStreamerFactory,          RAISEERRORSTREAMER_TAGNAME );
        addStreamerFactory( new IFStreamerFactory,                  IFSTREAMER_TAGNAME);
        addStreamerFactory( new FSSetStreamerFactory,               FSSETSTREAMER_TAGNAME );      
        addStreamerFactory( new FSGetStreamerFactory,               FSGETSTREAMER_TAGNAME );        
        addStreamerFactory( new DBOBJGetStreamerFactory,            DBOBJGETSTREAMER_TAGNAME    );  
        addStreamerFactory( new DBOBJSetStreamerFactory,            DBOBJSETSTREAMER_TAGNAME    );
        addStreamerFactory( new AutodescStreamerFactory,            AUTODESCSTREAMER_TAGNAME    );
        addStreamerFactory( new DDLStreamerFactory,                 DDLSTREAMER_TAGNAME );
        addStreamerFactory( new SQLStreamerFactory,                 SQLSTREAMER_TAGNAME );
        addStreamerFactory( new ZipStreamerFactory,                 ZIPSTREAMER_TAGNAME );    
        addStreamerFactory( new UnzipStreamerFactory,               UNZIPSTREAMER_TAGNAME );
        addStreamerFactory( new FuncCallStreamerFactory,            FUNCCALLSTREAMER_TAGNAME ); 
        addStreamerFactory( new ExecStreamerFactory,                EXECSTREAMER_TAGNAME );
        addStreamerFactory( new LangSetStreamerFactory,             LANGSETSTREAMER_TAGNAME );

        addStreamerFactory( new CacheDefinitionStreamerFactory,     CACHEDEFINITIONSTREAMER_TAGNAME );
        addStreamerFactory( new FuncDefineStreamerFactory,          FUNCDEFINESTREAMER_TAGNAME ); 
        addStreamerFactory( new LogStreamerFactory,                 LOGSTREAMER_TAGNAME ); 
        addStreamerFactory( new _ValuesStreamerFactory,             S_VALUESSTREAMER_TAGNAME );
        addStreamerFactory( new _NamedBufferSetStreamerFactory,     S_NAMEDBUFSETSTREAMER_TAGNAME );
        addStreamerFactory( new LangLoadStreamerFactory,            LANGLOADSTREAMER_TAGNAME );
        addStreamerFactory( new CacheScriptStreamerFactory,         CACHESCRIPTSTREAMER_TAGNAME );
        
        logout << "\n";

                DEBUG_OUT(XMLProcessor::loadStreamerFactories)

    }


    //_________________________________________________________________________
    //  LOADVALUERS
    //-------------------------------------------------------------------------
    void XMLProcessor::loadValuers( XMLFlowContext* p_pContext) const
    {
        p_pContext->addValuer( new DateValuer,                      DATEVALUER_TAG );
        p_pContext->addValuer( new EnvValuer,                       ENVVALUER_TAG );
        p_pContext->addValuer( new ParamValuer( p_pContext),        PARAMVALUER_TAG );
        p_pContext->addValuer( new XpathDBValuer,                   XPATHVALUER_TAG );
        p_pContext->addValuer( new SQLDBValuer,                     SQLVALUER_TAG );
        p_pContext->addValuer( new LangValuer( p_pContext),         LANGVALUER_TAG );

        logout << "\n";
    }

    //_________________________________________________________________________
    //  ADDSTREAMERFACTORY
    //-------------------------------------------------------------------------
    void XMLProcessor::addStreamerFactory ( XMLStreamerFactory* p_pFactory, const char* p_pszName)
    {
        DEBUG_IN(XMLProcessor::addStreamerFactory)

        p_pFactory->setParent(this);

                DEBUG_ECHO << "Load " << p_pszName << "...\n";
        m_vaStreamerFactories.add( p_pFactory, p_pszName);

                DEBUG_OUT(XMLProcessor::addStreamerFactory)
    }

    //_________________________________________________________________________
    //  GETSTREAMERFACTORY
    //-------------------------------------------------------------------------
    XMLStreamerFactory* XMLProcessor::getStreamerFactory ( const char* p_pszName) const
    {
        DEBUG_FUNC(XMLProcessor::getStreamerFactory)

        return m_vaStreamerFactories.get( p_pszName);
    }

// CONTEXT

    //_____________________________________________________________________
    //  SETCONTEXT
    //---------------------------------------------------------------------
    void XMLProcessor::setContext(XMLFlowContext* p_pContext)
    {
        DEBUG_FUNC(XMLProcessor::setContext)
        if(m_pContext)
        { 
            if(m_fOwnContext) delete p_pContext;
        }
        m_pContext = p_pContext;
    }

    //_____________________________________________________________________
    //  GETCONTEXT
    //---------------------------------------------------------------------
    XMLFlowContext* XMLProcessor::getContext() const
    {
        return m_pContext;
    }

// SCRIPT CACHE FEATURES

    //_____________________________________________________________________
    //  CACHESCRIPT
    //---------------------------------------------------------------------
    void XMLProcessor::cacheScript( RootStreamNode* p_pRootNode, const char* p_pszCacheName, unsigned int p_uiThreadId)
    {
        m_pvaScriptCache.add( p_pRootNode, p_pszCacheName);
    }

    //_____________________________________________________________________
    //  GETCACHEDSCRIPT
    //---------------------------------------------------------------------
    const RootStreamNode*   XMLProcessor::getCachedScript( const char* p_pszCacheName, unsigned int p_uiThreadId)
    {
        return m_pvaScriptCache.get( p_pszCacheName);
    }



    //_____________________________________________________________________
    //  COMPILE
    //---------------------------------------------------------------------
    RootStreamNode* XMLProcessor::compile( XMLStreamProvider* p_pInput, unsigned int p_uiThreadId ) const
    {
        //---------------------------------------------------------------------
        StreamSAX2Parser*           l_pStreamParser=0;
        XMLFlowBuilder*             l_pStreamBuilder=0;
        RootStreamNode*             l_pStreamRoot=0;
        XDFLSaxErrorReporter*   l_pErrReporter=0;   // Error reporter for the sax parsing
        //---------------------------------------------------------------------

        PREP_CATCH_XML_FLOW_ERROR;      

        logout << "\n--[ compiling ]-------------------------------------------------------\n";

        WATCH_XML_FLOW_ERROR { 

            l_pStreamRoot = new RootStreamNode;
            
            // build handlers
            l_pStreamBuilder = new XMLFlowBuilder(this, l_pStreamRoot, XMLPROCESSOR_ACTIVEURI);
            l_pErrReporter = new XDFLSaxErrorReporter( "XMLProcessor::processXML");

            // build parser
            l_pStreamParser = new StreamSAX2Parser(l_pStreamBuilder, l_pErrReporter);

            // parse !
            (*p_pInput) >> (*l_pStreamParser);
            l_pStreamParser->commitStream(true);

        } 
        CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN
        catch( ... )
        {
            // Unknown error handling

            MAKE_XMLFLOW_EXCEPTION( ERRCODE_LOC_XMLPROCESSOR + ERRCODE_CAUSE_UNKNOWN , "Unknown fatal error while compiling." , "", "XMLProcessor::compile", "", false );           
        }

    RELEASE_AND_RETURN: 

        logout << "----------------------------------------------------------------------\n";

        delete l_pStreamParser;
        delete l_pErrReporter;
        delete l_pStreamBuilder;

        ON_XML_FLOW_ERROR_DO delete l_pStreamRoot;
        ON_XML_FLOW_ERROR_THROW;
    
        return l_pStreamRoot;
    }
    
    //_____________________________________________________________________
    //  EXECUTE
    //---------------------------------------------------------------------
    int XMLProcessor::execute( const RootStreamNode* p_pRootNode, XMLStreamConsumer* p_pOutput, XMLFlowContext* p_pContext) const
    {
        //---------------------------------------------------------------------
        bool                l_fDelContext;
        bool                l_fDelOutput;
        unsigned int        l_uiError;
        //---------------------------------------------------------------------

        PREP_CATCH_XML_FLOW_ERROR;  
        
        logout << "\n--[ executing ]-------------------------------------------------------\n";

        WATCH_XML_FLOW_ERROR {      

            l_uiError = 0;
            l_fDelContext = false;
            if(! p_pContext)
            {
                // if no context provided; create one for the request
                p_pContext = new XMLFlowContext( this, getContext(),  0, getContext()->getEncoding());
                l_fDelContext = true;
            }

            l_fDelOutput=false;
            if(! p_pOutput)
            {
                // if no output provided, create a null consumer to receive data.
                p_pOutput = new NullConsumer();
                l_fDelOutput=true;
            }   

            loadValuers( p_pContext);

            // execute script : stream through root node
            p_pRootNode->streamXML( p_pOutput, p_pContext);

        } 
        CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN
        catch( ... )
        {
            // Unknown error handling

            MAKE_XMLFLOW_EXCEPTION( ERRCODE_LOC_XMLPROCESSOR + ERRCODE_CAUSE_UNKNOWN , "Unknown fatal error while executing." , "", "XMLProcessor::execute", "", false );           
        }

    RELEASE_AND_RETURN:

        logout << "----------------------------------------------------------------------\n";


        if(l_fDelContext) delete p_pContext;
        if(l_fDelOutput) delete p_pOutput;

        ON_XML_FLOW_ERROR_THROW;

        return l_uiError;

    }

    //_____________________________________________________________________
    //  PROCESS
    //---------------------------------------------------------------------
    int XMLProcessor::process( XMLStreamProvider* p_pInput , XMLStreamConsumer* p_pOutput, XMLFlowContext* p_pContext) const
    {
        //-----------------------------------------------------------------
        RootStreamNode*             l_pStreamRoot=0;
        unsigned int                l_uiError=0;
        unsigned int                l_uiThreadId=0;
        //-----------------------------------------------------------------
        PREP_CATCH_XML_FLOW_ERROR;

        if( p_pContext) l_uiThreadId = p_pContext->getThreadId();

        WATCH_XML_FLOW_ERROR
        {
            l_pStreamRoot = compile( p_pInput, l_uiThreadId);
            l_uiError = execute( l_pStreamRoot, p_pOutput, p_pContext);
        }
        CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN

    RELEASE_AND_RETURN:

        delete( l_pStreamRoot);
        ON_XML_FLOW_ERROR_THROW;
        return l_uiError;
    }


    //_____________________________________________________________________
    //  TICK
    //---------------------------------------------------------------------
    void XMLProcessor::tick(unsigned long  p_ulClock)
    {
        //-----------------------------------------------------------------
        unsigned int i;
        //-----------------------------------------------------------------

        logout << "\n! TICK #" << p_ulClock << "!";
        for( i=0; i< m_vaStreamerFactories.size(); i++)
        {
            m_vaStreamerFactories.get(i)->tick( p_ulClock);
        }
    }



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

END_XDFLENGINE_NS

---