---

dbobject.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  DBOBJECT.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 "dbobject.hpp"
#   include "valuers/xpathdbvaluer.hpp"
#   include "flow/consumers/streamsax2parser.hpp"

BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS DBOBJECTFIELD
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    // CONSTRUCTOR & DESTUCTOR


    //_____________________________________________________________________
    //  DBOBJECTFIELD
    //---------------------------------------------------------------------
    DBObjectField::DBObjectField( const char* p_pszName)
    {
        DEBUG_CREATE(DBObjectField)

        m_pszName = 0;
        m_pszValue = 0;
        m_pSAXDB_FieldDefinition = 0;
        
        setName(p_pszName);

        m_DBOBJParentNode=0;
        m_fCalculated=false;   
    }

    //_________________________________________________________________________
    //  DBOBJECTFIELD
    //-------------------------------------------------------------------------
    DBObjectField::DBObjectField( const DBOBJDefinitionField* p_pDBObjectFieldDef)
    {
        DEBUG_CREATE(DBObjectField)

        m_pszName = 0;
        m_pszValue = 0;
        m_pSAXDB_FieldDefinition = 0;
        
        if(p_pDBObjectFieldDef) setDefinition( p_pDBObjectFieldDef);

        m_DBOBJParentNode=0;
        m_fCalculated=false;   
    }

    //_________________________________________________________________________
    //  ~DBOBJECTFIELD
    //-------------------------------------------------------------------------
    DBObjectField::~DBObjectField()
    {
        DEBUG_DEL(DBObjectField)

        m_pszName=releaseCharBuffer( m_pszName);  
        m_pszValue=releaseCharBuffer( m_pszValue);
        m_fAttribute = 0;
        m_pSAXDB_FieldDefinition = 0;
    }

    // GETTERS

    //_________________________________________________________________________
    //  GETTYPE
    //-------------------------------------------------------------------------
    int DBObjectField::getType() const
    {
        DEBUG_FUNC(DBObjectField::getType)

        return DBOBJECTTYPE_FIELD;
    }

    //_________________________________________________________________________
    //  GETNAME
    //-------------------------------------------------------------------------
    const char*  DBObjectField::getName() const 
    {
        DEBUG_FUNC(DBObjectField::getName)

        DEBUG_ECHO << m_pszName << "\n";
        return exportCharBuffer( m_pszName);
    }

    //_________________________________________________________________________
    //  GETVALUE
    //-------------------------------------------------------------------------
    const char*  DBObjectField::getValue() 
    {
        //---------------------------------------------------------------------
        DBOBJSetAction l_intAction;
        const   char*  l_pszValue;
        char*   l_pszCalculatedValue;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBObjectField::getValue)


        if(! m_fCalculated && m_pSAXDB_FieldDefinition )
        {

            l_intAction = DBOBJaction_Unspec;
            if(m_DBOBJParentNode) l_intAction = m_DBOBJParentNode->getAction();

            l_pszValue =  DBOBJDEFFIELD_NOVALUE;

            switch( l_intAction)
            {
                case DBOBJaction_Insert:
                    l_pszValue = m_pSAXDB_FieldDefinition->getIValue();
                    break;
                case DBOBJaction_Update:
                    l_pszValue = m_pSAXDB_FieldDefinition->getUValue();
                    break;
                case DBOBJaction_Delete:
                    l_pszValue = m_pSAXDB_FieldDefinition->getDValue();
                    break;
            }

            if( strcmp( l_pszValue, DBOBJDEFFIELD_NOVALUE) == 0) l_pszValue=m_pSAXDB_FieldDefinition->getValue();
            if( strcmp( l_pszValue, DBOBJDEFFIELD_NOVALUE) == 0) l_pszValue=m_pszValue;
            if( !l_pszValue) l_pszValue="";
            l_pszCalculatedValue = m_DBOBJParentNode->calculateRelValue( l_pszValue);

            if( strcmp( l_pszCalculatedValue, DBOBJDEFFIELD_NOVALUE) == 0 ) l_pszCalculatedValue=0;
            if(!l_pszCalculatedValue) l_pszCalculatedValue=copyCharBuffer("");

            m_pszValue=importCharBuffer( m_pszValue,l_pszCalculatedValue);
            l_pszCalculatedValue = releaseCharBuffer( l_pszCalculatedValue);
            m_fCalculated=true;
        }

        return m_pszValue;
    }

    //_________________________________________________________________________
    //  ISATTRIBUTE
    //-------------------------------------------------------------------------
    bool DBObjectField::isAttribute() const
    {
        DEBUG_FUNC(DBObjectField::isAttribute)
        return m_fAttribute;
    }

    //_________________________________________________________________________
    //  GETDEFINITION
    //-------------------------------------------------------------------------
    const DBOBJDefinitionField* DBObjectField::getDefinition() const
    {
        DEBUG_FUNC(DBObjectField::getDefinition)
        return m_pSAXDB_FieldDefinition;
    }

    //_________________________________________________________________________
    //  GETXML
    //-------------------------------------------------------------------------
    void DBObjectField::getXML(XMLStreamConsumer* p_pXMLBufOut)
    {

        DEBUG_FUNC(DBObjectField::getXML)

        if(m_fAttribute)
        {
            (*p_pXMLBufOut) << (m_pszName+1) << "=\"" << getValue() << "\" ";
        }
        else
        {
            (*p_pXMLBufOut) << "<" << m_pszName << "><![CDATA[" << getValue() << "]]></" << m_pszName << ">\n";
        }

    }

    // SETTERS

    //_____________________________________________________________________
    //  SETNAME
    //---------------------------------------------------------------------
    void DBObjectField::setName( const char* p_pszName)
    {
        DEBUG_FUNC(DBObjectField::setName)

        m_pszName=importCharBuffer( m_pszName, p_pszName);
        if(m_pszName[0]==DBOBJDEFFIELD_ATTR) setAttribute(true);
        else setAttribute(false);
    }

    //_____________________________________________________________________
    //  SETATTRIBUTE
    //---------------------------------------------------------------------
    void DBObjectField::setAttribute( bool p_fAttribute)
    {
        DEBUG_FUNC(DBObjectField::setAttribute)

        m_fAttribute = p_fAttribute;
    }


    //_________________________________________________________________________
    //  SETVALUE
    //-------------------------------------------------------------------------
    void DBObjectField::setValue( const char* p_pszFieldValue)
    {
        DEBUG_FUNC(DBObjectField::setValue)

        //logout << m_pszName << "=" << p_strFieldValue << "\n";
        m_pszValue=importCharBuffer( m_pszValue, p_pszFieldValue);
    }

    //_________________________________________________________________________
    //  SETPARENT
    //-------------------------------------------------------------------------
    void DBObjectField::setParent( DBObjectNode* p_DBOBJParentNode)
    {
        DEBUG_FUNC(DBObjectField::setParent)

        m_DBOBJParentNode=p_DBOBJParentNode;
    }

    //_________________________________________________________________________
    //  SETDEFINITION
    //-------------------------------------------------------------------------
    void DBObjectField::setDefinition( const DBOBJDefinitionField* p_pDBObjectFieldDef)
    {
        DEBUG_FUNC(DBObjectField::setDefinition)

        m_pSAXDB_FieldDefinition = p_pDBObjectFieldDef;
        m_fAttribute = m_pSAXDB_FieldDefinition->isAttribute() ;   
        m_pszName = importCharBuffer( m_pszName, m_pSAXDB_FieldDefinition->getName());
    }



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








//============================================================================= 
//  CLASS DBOBJECTNODE
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_________________________________________________________________________
    //  DBOBJECTNODE
    //-------------------------------------------------------------------------
    DBObjectNode::DBObjectNode(const DBOBJDefinitionNode* p_pDBOBJDefNode )
    {
        m_pszName = 0;
        m_pValuableParent = 0;
        m_pParentNode = 0;
        m_pXpathValuer = 0;

        setDefinition( p_pDBOBJDefNode);
        setAction( DBOBJaction_Unspec);

        DEBUG_CREATE(DBObjectNode)
    }


    //_________________________________________________________________________
    //  ~DBOBJECTNODE
    //-------------------------------------------------------------------------
    DBObjectNode::~DBObjectNode()
    {
        DEBUG_DEL(DBObjectNode)

        m_pszName = releaseCharBuffer( m_pszName);
        deleteTree();
    }

    // GETTERS

    //_________________________________________________________________________
    //  GETTYPE
    //-------------------------------------------------------------------------
    int DBObjectNode::getType() const
    {
        DEBUG_FUNC(DBObjectField::getType)
        return DBOBJECTTYPE_NODE;
    }


    //_________________________________________________________________________
    //  GETNAME
    //-------------------------------------------------------------------------
    const char* DBObjectNode::getName() const
    {
        DEBUG_FUNC(DBObjectNode::getName)
        return exportCharBuffer( m_pszName);
    }

    //_________________________________________________________________________
    //  GETACTION
    //-------------------------------------------------------------------------
    DBOBJSetAction DBObjectNode::getAction() const
    {
        DEBUG_FUNC(DBObjectNode::getAction)
        return m_intAction;

    }

    //_________________________________________________________________________
    //  GETPARENT
    //-------------------------------------------------------------------------
    DBObjectNode* DBObjectNode::getParent() const
    {
        DEBUG_FUNC(DBObjectNode::getParent)
        return m_pParentNode; 
    }

    //_________________________________________________________________________
    //  GETDEFINITION
    //-------------------------------------------------------------------------
    const DBOBJDefinitionNode* DBObjectNode::getDefinition() const
    {
        DEBUG_FUNC(DBObjectNode::getDefinition)
        return m_pDBObjectNodeDefinition;
    }

    //_________________________________________________________________________
    //  GETVALUABLE
    //-------------------------------------------------------------------------
    XMLValuable* DBObjectNode::getValuable()
    {
        DEBUG_FUNC(DBObjectNode::getValuable)
        if(! m_pValuableParent) return m_pParentNode->getValuable();
        return m_pValuableParent;
    }

    // SETTERS

    //_________________________________________________________________________
    //  SETACTION
    //-------------------------------------------------------------------------
    void DBObjectNode::setAction( DBOBJSetAction p_intAction)
    {
        DEBUG_FUNC(DBObjectNode::setAction)
        m_intAction = p_intAction;
    }


    //_________________________________________________________________________
    //  SETPARENT
    //-------------------------------------------------------------------------
    void DBObjectNode::setParent( DBObjectNode* p_DBOBJParentNode)
    {
        DEBUG_FUNC(DBObjectNode::setParent)

        m_pParentNode =  p_DBOBJParentNode;
    }

    //_________________________________________________________________________
    //  SETDEFINITION
    //-------------------------------------------------------------------------
    void DBObjectNode::setDefinition( const DBOBJDefinitionNode* p_pDBOBJDefNode)
    {
        DEBUG_FUNC(DBObjectNode::setDefinition)

        m_pDBObjectNodeDefinition =   p_pDBOBJDefNode;
        m_pszName = importCharBuffer( m_pszName, m_pDBObjectNodeDefinition->getName());
    }

    //_________________________________________________________________________
    //  SETVALUABLE
    //-------------------------------------------------------------------------
    void DBObjectNode::setValuable(XMLValuable* p_pValuableParent)
    {
        DEBUG_FUNC(DBObjectNode::setValuable)

        m_pValuableParent = p_pValuableParent;
    }

    // Children collection builder & accessors

    //_________________________________________________________________________
    //  ADDCHILDNODE
    //-------------------------------------------------------------------------
    void DBObjectNode::addChildNode( DBObjectNode* p_pChildNode)
    {
        DEBUG_FUNC(DBObjectNode::addChildNode)

        m_vaChildren.add( p_pChildNode,p_pChildNode->getName());
        p_pChildNode->setParent(this);

    }

    //_________________________________________________________________________
    //  REMOVECHILDNODE
    //-------------------------------------------------------------------------
    void DBObjectNode::removeChildNode( unsigned int p_uiIndex, bool p_fDestroy)
    {
        //---------------------------------------------------------------------
        DBObjectNode* l_pChildNode = 0;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBObjectNode::removeChildNode)

        l_pChildNode = m_vaChildren.remove(p_uiIndex);
        if(l_pChildNode)
        {
            l_pChildNode->setParent(0);
            if( p_fDestroy) delete l_pChildNode;
        }
    }

    //_________________________________________________________________________
    //  REMOVECHILDNODE
    //-------------------------------------------------------------------------
    void DBObjectNode::removeChildNode( const char* p_pszName, unsigned int p_uiIndex, bool p_fDestroy)
    {
        //---------------------------------------------------------------------
        DBObjectNode* l_pChildNode = 0;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBObjectNode::removeChildNode)

        l_pChildNode = m_vaChildren.get(p_pszName, p_uiIndex);
        if(l_pChildNode)
        {
            l_pChildNode->setParent(0);
            if( p_fDestroy) delete l_pChildNode;
        }       
    }

    //_________________________________________________________________________
    //  GETCHILDNODESCOUNT
    //-------------------------------------------------------------------------
    unsigned int DBObjectNode::getChildNodesCount() const
    {
        DEBUG_FUNC(DBObjectNode::getChildNodesCount)
        return m_vaChildren.size(); 
    }

    //_________________________________________________________________________
    //  GETCHILDNODESCOUNT
    //-------------------------------------------------------------------------
    unsigned int DBObjectNode::getChildNodesCount( const char* p_pszName) const
    {   
        DEBUG_FUNC(DBObjectNode::getChildNodesCount)
        return m_vaChildren.count( p_pszName);
    }

    //_________________________________________________________________________
    //  GETCHILDNODE
    //-------------------------------------------------------------------------
    DBObjectNode* DBObjectNode::getChildNode( unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBObjectNode::getChildNode)
        return m_vaChildren.get(p_uiIndex);
    }

    //_________________________________________________________________________
    //  GETCHILDNODE
    //-------------------------------------------------------------------------
    DBObjectNode* DBObjectNode::getChildNode( const char* p_pszName, unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBObjectNode::getChildNode(name))
        return m_vaChildren.get(p_pszName, p_uiIndex);
    }

    //_____________________________________________________________________
    //  GETCURRENTFIELD
    //---------------------------------------------------------------------
    DBObjectNode* DBObjectNode::getCurrentChild()
    {
        DEBUG_FUNC(DBObjectNode::getCurrentChild)
        return m_vaChildren.current();
    }

    //_____________________________________________________________________
    //  MOVEPREVIOUSFIELD
    //---------------------------------------------------------------------
    void DBObjectNode::movePreviousChild()
    {
        DEBUG_FUNC(DBObjectNode::movePreviousChild)
        m_vaChildren.movePrevious();
    }

    //_____________________________________________________________________
    //  MOVENEXTFIELD
    //---------------------------------------------------------------------
    void DBObjectNode::moveNextChild()
    {
        DEBUG_FUNC(DBObjectNode::moveNextChild)
        m_vaChildren.moveNext();
    }

    //_____________________________________________________________________
    //  moveFirstField
    //---------------------------------------------------------------------
    void DBObjectNode::moveFirstChild()
    {
        DEBUG_FUNC(DBObjectNode::moveFirstChild)
        m_vaChildren.moveFirst();
    }

    //_____________________________________________________________________
    //  moveLastField
    //---------------------------------------------------------------------
    void DBObjectNode::moveLastChild()
    {
        DEBUG_FUNC(DBObjectNode::moveLastChild)
        m_vaChildren.moveLast();
    }

    // FIELDS COLLECTION BUILDER & ACCESSORS

    //_________________________________________________________________________
    //  ADDFIELD
    //-------------------------------------------------------------------------
    void DBObjectNode::addField(DBObjectField* p_pField)
    {
        DEBUG_FUNC(DBObjectNode::addField)

        m_vaFields.add(p_pField, p_pField->getName());
        p_pField->setParent( this );
    }

    //_________________________________________________________________________
    //  REMOVEFIELD
    //-------------------------------------------------------------------------
    void DBObjectNode::removeField( unsigned int p_uiIndex, bool p_fDestroy)
    {
        DBObjectField* l_pField;

        DEBUG_FUNC(DBObjectNode::removeField)

        l_pField=m_vaFields.remove(p_uiIndex);
        if(l_pField)
        {
            l_pField->setParent(0);
            if(p_fDestroy) delete l_pField;
        }
    }

    //_________________________________________________________________________
    //  REMOVEFIELD
    //-------------------------------------------------------------------------
    void DBObjectNode::removeField( const char* p_pszName, bool p_fDestroy)
    {
        DBObjectField* l_pField;

        DEBUG_FUNC(DBObjectNode::removeField)

        l_pField=m_vaFields.remove(p_pszName);
        if(l_pField)
        {
            l_pField->setParent(0);
            if(p_fDestroy) delete l_pField;
        }
    }

    //_________________________________________________________________________
    //  GETFIELDSCOUNT
    //-------------------------------------------------------------------------
    unsigned int DBObjectNode::getFieldsCount() const
    {
        DEBUG_FUNC(DBObjectNode::getFieldsCount)
        return m_vaFields.size();
    }

    //_________________________________________________________________________
    //  GETFIELD
    //-------------------------------------------------------------------------
    DBObjectField* DBObjectNode::getField(unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBObjectNode::getField(index))
        
        return m_vaFields.get(p_uiIndex);
    }

    //_________________________________________________________________________
    //  GETFIELD
    //-------------------------------------------------------------------------
    DBObjectField* DBObjectNode::getField(const char* p_pszName) const
    {
        DEBUG_FUNC(DBObjectNode::getField(name))

        return m_vaFields.get(p_pszName);
    }

    //_____________________________________________________________________
    //  GETCURRENTFIELD
    //---------------------------------------------------------------------
    DBObjectField* DBObjectNode::getCurrentField()
    {
        DEBUG_FUNC(DBObjectNode::getCurrentField)
        return m_vaFields.current();
    }

    //_____________________________________________________________________
    //  MOVEPREVIOUSFIELD
    //---------------------------------------------------------------------
    void DBObjectNode::movePreviousField()
    {
        DEBUG_FUNC(DBObjectNode::movePreviousField)
        m_vaFields.movePrevious();
    }

    //_____________________________________________________________________
    //  MOVENEXTFIELD
    //---------------------------------------------------------------------
    void DBObjectNode::moveNextField()
    {
        DEBUG_FUNC(DBObjectNode::moveNextField)
        m_vaFields.moveNext();
    }

    //_____________________________________________________________________
    //  moveFirstField
    //---------------------------------------------------------------------
    void DBObjectNode::moveFirstField()
    {
        DEBUG_FUNC(DBObjectNode::moveFirstField)
        m_vaFields.moveFirst();
    }

    //_____________________________________________________________________
    //  moveLastField
    //---------------------------------------------------------------------
    void DBObjectNode::moveLastField()
    {
        DEBUG_FUNC(DBObjectNode::moveLastField)
        m_vaFields.moveLast();
    }


    //_________________________________________________________________________
    //  GETXML
    //-------------------------------------------------------------------------
    void DBObjectNode::getXML(XMLStreamConsumer* p_pXMLBufOut)
    {
         //_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
        DBObjectField* l_pDBObjectField;
        unsigned int i;
         //_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

        DEBUG_FUNC(DBObjectNode::getXML)

        (*p_pXMLBufOut) << "\n<" << m_pszName << " " ;

        if (m_intAction==DBOBJaction_Delete)    (*p_pXMLBufOut) << "map_status='delete' " ;
        if (m_intAction==DBOBJaction_Insert)    (*p_pXMLBufOut) << "map_status='insert' " ;
        if (m_intAction==DBOBJaction_Update)    (*p_pXMLBufOut) << "map_status='update' " ;

        for( i=0 ; i < getFieldsCount() ; i++)
        {
            l_pDBObjectField = this->getField(i);
            if(l_pDBObjectField->isAttribute()) l_pDBObjectField->getXML(p_pXMLBufOut);
        }

        (*p_pXMLBufOut) << ">\n";

        for( i=0 ; i < getFieldsCount() ; i++)
        {
            l_pDBObjectField = this->getField(i);
            if(! l_pDBObjectField->isAttribute()) l_pDBObjectField->getXML(p_pXMLBufOut);
        }

        for( i=0 ; i < getChildNodesCount() ; i++)
        {
            getChildNode(i)->getXML(p_pXMLBufOut);  
        }

        (*p_pXMLBufOut) << "</" << m_pszName << ">\n";

    }

    //_________________________________________________________________________
    //  SELECTSINGLENODE
    //-------------------------------------------------------------------------
    DBObject* DBObjectNode::selectSingleNode(const char* p_pszPath)
    {
         //_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
        char*            l_pszSelPath;
        char*            l_pszNextPath;
        DBObject*        l_pSelOBJ = 0;
        DBObjectNode*    l_pChild = 0;
         //_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

        DEBUG_FUNC(DBObjectNode::selectSingleNode)

        DEBUG_ECHO << m_pszName << ":" << p_pszPath << "\n";

        // empty request : return self
        if( strlen(p_pszPath) == 0 ) return (DBObject*) this;

        l_pszSelPath = copyCharBuffer( p_pszPath);
        l_pszNextPath = strchr(l_pszSelPath, DBOBJECTNODE_SELREQSEP);
        if(! l_pszNextPath) 
        {
            // last term of a path, return an attribute
            // if(p_pszPath[0] == DBOBJECTNODE_ATTRMARK) p_pszPath=p_pszPath+1;

            l_pSelOBJ = (DBObject*) getField(p_pszPath);
        }
        else
        {
            l_pszNextPath[0]='\0';
            l_pszNextPath ++;
            DEBUG_ECHO << l_pszSelPath << "!" << l_pszNextPath   << "\n";

            // self
            if( strcmp( l_pszSelPath, DBOBJECTNODE_SELF) == 0)   l_pSelOBJ = (DBObject*) selectSingleNode( l_pszNextPath);
            // parent
            if( strcmp( l_pszSelPath, DBOBJECTNODE_PARENT) == 0) l_pSelOBJ = (DBObject*) m_pParentNode->selectSingleNode( l_pszNextPath);
            // other
            if(!l_pSelOBJ)
            {
                l_pChild=getChildNode( l_pszSelPath);
                if(l_pChild) l_pSelOBJ = (DBObject*) l_pChild->selectSingleNode( l_pszNextPath);
                else l_pSelOBJ = 0;
            }
        }
        releaseCharBuffer( l_pszSelPath);
        return l_pSelOBJ;
    }



    //_____________________________________________________________________
    //  GETVALUABLE
    //---------------------------------------------------------------------
    char* DBObjectNode::calculateRelValue( const char* p_pszExpr)
    {
        if(! m_pXpathValuer) m_pXpathValuer = (XpathDBValuer*) getValuable()->getValuer( XPATHVALUER_TAG);

        m_pXpathValuer->setRoot( this);

        return getValuable()->calculateValue( p_pszExpr);
    }


    // PRIVATES

    //_________________________________________________________________________
    //  DELETETREE
    //-------------------------------------------------------------------------
    void DBObjectNode::deleteTree()
    {   

        DEBUG_IN(DBObjectNode::deleteTree)

        // kill fields
        while(! m_vaFields.empty()) delete m_vaFields.pop();

        // kill chidren
        while( ! m_vaChildren.empty()) delete m_vaChildren.pop();

        DEBUG_OUT(DBObjectNode::deleteTree)
    }

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




//============================================================================= 
//  CLASS DBOBJECTSAXBUILDER
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_________________________________________________________________________
    //  BUILDDBOBJECT
    //-------------------------------------------------------------------------
    void DBObjectSAXBuilder::buildDBObject(XMLFlowContext* p_pContext, XMLStreamProvider* p_pInput, const DBOBJDefinitionNode* p_pDBOBJDefNode, DBOBJSetAction l_intBaseAction)
    {
        //---------------------------------------------------------------------
        DBObjectSAXBuilder*         l_pDBObjectSAXBuilder=0;
        StreamSAX2Parser*           l_pStreamParser=0;
        XDFLSaxErrorReporter*   l_pErrReporter=0;
        //---------------------------------------------------------------------

        DEBUG_IN(DBObjectSAXBuilder::buildDBObject);
        PREP_CATCH_XML_FLOW_ERROR;
        
        WATCH_XML_FLOW_ERROR { 

            //  Create our SAX handler object and install it on the parser, as the document and error handler.
            l_pDBObjectSAXBuilder=new DBObjectSAXBuilder(p_pContext, p_pDBOBJDefNode, l_intBaseAction);
            l_pErrReporter= new XDFLSaxErrorReporter("DBObjectSAXBuilder::buildDBObject");

            // create parser
            l_pStreamParser = new StreamSAX2Parser(l_pDBObjectSAXBuilder, l_pErrReporter);

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


        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN:

        delete l_pStreamParser;
        delete l_pErrReporter;
        delete l_pDBObjectSAXBuilder;

        DEBUG_OUT(DBObjectSAXBuilder::buildDBObject);
        ON_XML_FLOW_ERROR_THROW;
    }

    //  Constructors and Destructor  

    //_________________________________________________________________________
    //  DBOBJECTSAXBUILDER
    //-------------------------------------------------------------------------
    DBObjectSAXBuilder::DBObjectSAXBuilder(XMLFlowContext* p_pContext, const DBOBJDefinitionNode* p_pDBOBJDefNode,DBOBJSetAction l_intBaseAction)
    {
        m_intBaseAction = l_intBaseAction;
        m_pSAXDB_objectDef=p_pDBOBJDefNode;
        m_pSAXDB_curFieldDef=0;
        m_pszCurFieldName = 0;
        m_pszCurFieldValue = 0;
        m_pContext = p_pContext;
        DEBUG_CREATE(DBObjectSAXBuilder)
    }

    //_________________________________________________________________________
    //  ~DBOBJECTSAXBUILDER
    //-------------------------------------------------------------------------
    DBObjectSAXBuilder::~DBObjectSAXBuilder()
    {
        DEBUG_DEL(DBObjectSAXBuilder)

        m_pszCurFieldName = releaseCharBuffer( m_pszCurFieldName);
        m_pszCurFieldValue = releaseCharBuffer( m_pszCurFieldValue);

        while(!m_vaNodes.empty()) delete m_vaNodes.pop();
        while(!m_vaObjects.empty()) delete m_vaObjects.pop();

    }


    //  CONTENTHANDLER  

    //_________________________________________________________________________
    //  STARTELEMENT
    //-------------------------------------------------------------------------
    void DBObjectSAXBuilder::startElement(  const XMLCh* const uri, 
                                            const XMLCh* const localname, 
                                            const XMLCh* const qname, 
                                            const Attributes& attrs)
    {
        //---------------------------------------------------------------------
        const DBOBJDefinitionNode*  l_pSAXDB_nodeDef=0;
        const DBOBJDefinitionField*   l_pDBObjectFieldDef=0;
        DBObjectNode*           l_pSAXDB_node=0;
        DBObjectField*          l_pDBObjectField=0;
        char                    l_szTagName[XMLPROCESSOR_MAX_TAG_SIZE];
        char                    l_szAttrName[XMLPROCESSOR_MAX_ATTRNAME_SIZE];
        char                    l_szAttrValue[XMLPROCESSOR_MAX_ATTRVAL_SIZE];
        DBOBJSetAction          l_intAction;
        unsigned int            l_uiAttrsCount;
        bool                    l_fRoot;
        bool                    l_fNode;
        unsigned int            i;
        //---------------------------------------------------------------------

        DEBUG_IN(DBObjectSAXBuilder::startElement);
        PREP_CATCH_XML_FLOW_ERROR;
        
        WATCH_XML_FLOW_ERROR { 

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

            DEBUG_ECHO << (char*) &l_szTagName << "\n";

            // get node or field definition
            if( m_vaNodes.empty() )
            {
                // root node ?
                l_fRoot = true;

                if(  strcmp( m_pSAXDB_objectDef->getName(), (char*) &l_szTagName) == 0 ) 
                {
                    l_fNode = true;
                    l_pSAXDB_nodeDef = m_pSAXDB_objectDef;

                }
                else
                {
                    l_fNode = false;
                    l_pSAXDB_nodeDef = 0;
                }
            }
            else
            {
                // not a root node
                l_fRoot = false;
                l_fNode = true;
                l_pSAXDB_nodeDef = m_vaNodes.top()->getDefinition()->getChildNode( (char*) &l_szTagName);

                if(!l_pSAXDB_nodeDef)
                {   // not a node, a field
                    l_fNode = false;
                    l_pDBObjectFieldDef = m_vaNodes.top()->getDefinition()->getField( (char*) &l_szTagName);
/*
                    // ERRCHECK : field exists ?
                    if( !l_pDBObjectFieldDef) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DBOBJECT + ERRCODE_CAUSE_MISSINGREF , "Unable to find field or node definition"  , (char*) &l_szTagName, "DBObjectSAXBuilder::startElement", "", false);
*/
                    DEBUG_ECHO << "(field)" << "\n";
                }
            }
            
            // build node
            if(l_fNode)
            {
                if(l_pSAXDB_nodeDef)
                {
                    l_pSAXDB_node = new DBObjectNode( l_pSAXDB_nodeDef);
                    //l_pSAXDB_node->setValuable((XMLValuable*) m_pSAXDB_request);

                    SAX_getAttrValue(attrs,DBOBJECTNODE_ACTION,"", (char*)&l_szAttrValue);
                    l_intAction = translateAction( (char*) &l_szAttrValue);

                    // calculate action
                    if(l_fRoot) l_intAction=calcAction( l_intAction, m_intBaseAction /*m_pSAXDB_request->getAction()*/);
                    else l_intAction=calcAction( l_intAction, m_vaNodes.top()->getAction());         

                    l_pSAXDB_node->setAction(l_intAction);

                    // build attributes fields
                    l_uiAttrsCount = attrs.getLength();
                    for (i=0 ; i< l_uiAttrsCount ; i++)
                    {
                        XSTR(m_pContext->getTranscoder(), attrs.getLocalName( i), (char*)(&l_szAttrName)+1);
                        XSTR(m_pContext->getTranscoder(), attrs.getValue( i), (char*)&l_szAttrValue);

                        if( ( strcmp( ((char*)&l_szAttrName)+1, DBOBJECTNODE_ACTION) != 0 ) && (strcmp( ((char*)&l_szAttrName)+1,"map_status")!=0) )
                        {
                            l_szAttrName[0] = DBOBJDEFFIELD_ATTR;
                            DEBUG_ECHO << (char*) &l_szAttrName << "=" << (char*) &l_szAttrValue << "\n";

                            l_pDBObjectFieldDef = l_pSAXDB_nodeDef->getField( (char*) &l_szAttrName );
                            if(l_pDBObjectFieldDef)
                            {
                                //if definition found, add to node's fields
                                l_pDBObjectField = new DBObjectField( l_pDBObjectFieldDef);
                            }
                            else
                            {
                                l_pDBObjectField = new DBObjectField( l_szAttrName);
                            }
                            l_pDBObjectField->setValue( (char*) &l_szAttrValue);
                            l_pSAXDB_node->addField( l_pDBObjectField );
                        }
                    }

                    //stack node
                    m_vaNodes.push(l_pSAXDB_node);
                }
            }
            
            // store field definition until getting its end tag
            if( !l_fNode && !l_fRoot)
            {
                if(l_pDBObjectFieldDef)
                {
                    m_pszCurFieldName = releaseCharBuffer( m_pszCurFieldName);
                    m_pSAXDB_curFieldDef=l_pDBObjectFieldDef;
                }
                else
                {
                    m_pszCurFieldName = copyCharBuffer( l_szTagName);
                    l_pDBObjectFieldDef = 0;
                }
                m_pszCurFieldValue = releaseCharBuffer( m_pszCurFieldValue);
            }


            if( !l_fNode && l_fRoot)
            {
                m_pSAXDB_curFieldDef=0;
            }

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN:
        
        
        DEBUG_OUT(DBObjectSAXBuilder::startElement)
        ON_XML_FLOW_ERROR_THROW;
    }

    //_________________________________________________________________________
    //  ENDELEMENT
    //-------------------------------------------------------------------------
    void DBObjectSAXBuilder::endElement(       const XMLCh* const uri,
                                               const XMLCh* const localname,
                                               const XMLCh* const qname)
    {
        //---------------------------------------------------------------------
        DBObjectNode*           l_pSAXDB_node;
        DBObjectField*          l_pDBObjectField;
        char                    l_szTagName[XMLPROCESSOR_MAX_TAG_SIZE];
        //---------------------------------------------------------------------
        
        DEBUG_IN(DBObjectSAXBuilder::endElement)
        PREP_CATCH_XML_FLOW_ERROR;
        
        WATCH_XML_FLOW_ERROR { 

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

            DEBUG_ECHO << l_szTagName << "\n";
            
            if( m_pSAXDB_curFieldDef || m_pszCurFieldName)
            {  
                // closing a field node, create field with stored data, and add created field object to stacked node
                DEBUG_ECHO << l_szTagName << "=" << m_pszCurFieldValue << "\n";

                if(m_pSAXDB_curFieldDef) l_pDBObjectField = new DBObjectField( m_pSAXDB_curFieldDef);
                else l_pDBObjectField = new DBObjectField( m_pszCurFieldName);
                l_pDBObjectField->setValue( m_pszCurFieldValue);

                m_vaNodes.top()->addField( l_pDBObjectField );
                m_pSAXDB_curFieldDef=0;
                m_pszCurFieldName = releaseCharBuffer( m_pszCurFieldName);
                m_pszCurFieldValue=releaseCharBuffer( m_pszCurFieldValue);
            }
            else
            {
                // pop top stacked node and adds its to the previous one's children collection    
                if(! m_vaNodes.empty())
                {      
                    l_pSAXDB_node=m_vaNodes.top();
                    if( strcmp( l_pSAXDB_node->getName(), (char*) &l_szTagName) == 0)
                    {
                        m_vaNodes.pop();
                        if(! m_vaNodes.empty())
                        {
                            m_vaNodes.top()->addChildNode( l_pSAXDB_node);
                        }
                        else
                        {
                            //logout << l_pSAXDB_node->getName() << "\n";
                            logout << ".";
                            m_vaObjects.push( l_pSAXDB_node);
                        }
                    }
                }
            }

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN:

        DEBUG_OUT(DBObjectSAXBuilder::endElement)
        ON_XML_FLOW_ERROR_THROW;
    }

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

        DEBUG_IN(DBObjectSAXBuilder::characters)
        PREP_CATCH_XML_FLOW_ERROR;
        
        WATCH_XML_FLOW_ERROR { 

            // if there's a current field, store value
            if( m_pSAXDB_curFieldDef || m_pszCurFieldName )
            {
                l_pszChars= XSTR(m_pContext->getTranscoder(), chars, length);
                l_pszTrimmedChars = trimCharBuffer( l_pszChars); 
                l_pszChars = releaseCharBuffer( l_pszChars);

                m_pszCurFieldValue = concatCharBuffer( m_pszCurFieldValue, l_pszTrimmedChars);
            }
        
        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN:

        l_pszChars = releaseCharBuffer( l_pszChars);
        l_pszTrimmedChars = releaseCharBuffer( l_pszTrimmedChars);
        
        DEBUG_OUT(DBObjectSAXBuilder::characters)
        ON_XML_FLOW_ERROR_THROW;
           
    }

    //_________________________________________________________________________
    //  TRANSLATEACTION
    //-------------------------------------------------------------------------
    DBOBJSetAction DBObjectSAXBuilder::translateAction(const char* p_pszAction)
    {
        //---------------------------------------------------------------------
        DBOBJSetAction l_intAction;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBOBJSetRequest::translateAction)

        l_intAction = DBOBJaction_Unspec;
        if( strcmp( p_pszAction, DBOBJECTNODE_ACTIONNONE) == 0)   l_intAction = DBOBJaction_None;
        if( strcmp( p_pszAction, DBOBJECTNODE_ACTIONINSERT) == 0) l_intAction = DBOBJaction_Insert;
        if( strcmp( p_pszAction, DBOBJECTNODE_ACTIONUPDATE) == 0) l_intAction = DBOBJaction_Update;
        if( strcmp( p_pszAction, DBOBJECTNODE_ACTIONDELETE) == 0) l_intAction = DBOBJaction_Delete;

        return l_intAction;
    }


    //_________________________________________________________________________
    //  TRANSLATEACTION
    //-------------------------------------------------------------------------
    char* DBObjectSAXBuilder::translateAction(DBOBJSetAction p_Action)
    {
        //---------------------------------------------------------------------
        const char* l_pszAction;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBOBJSetRequest::translateAction)

        l_pszAction = "";
        if( p_Action == DBOBJaction_None )   l_pszAction = DBOBJECTNODE_ACTIONNONE;
        if( p_Action == DBOBJaction_Insert ) l_pszAction = DBOBJECTNODE_ACTIONINSERT;
        if( p_Action == DBOBJaction_Update ) l_pszAction = DBOBJECTNODE_ACTIONUPDATE;
        if( p_Action == DBOBJaction_Delete ) l_pszAction = DBOBJECTNODE_ACTIONDELETE;

        return copyCharBuffer( l_pszAction);
    }


    // PRODUCED OBJECTS

    //_____________________________________________________________________
    //  GETOBJECTCOUNT
    //---------------------------------------------------------------------     
    unsigned int DBObjectSAXBuilder::getObjectsCount()
    {
        return m_vaObjects.size();
    }

    //_____________________________________________________________________
    //  POPOBJECT
    //---------------------------------------------------------------------
    DBObjectNode* DBObjectSAXBuilder::popObject()
    {
        DBObjectNode* l_pDBObjectNode;
        l_pDBObjectNode= m_vaObjects.bottom();
        m_vaObjects.remove((unsigned int)0);
        return l_pDBObjectNode;
    }

    //_________________________________________________________________________
    //  CALCACTION
    //-------------------------------------------------------------------------
    DBOBJSetAction DBObjectSAXBuilder::calcAction( DBOBJSetAction p_intCurAction, DBOBJSetAction p_intParentAction)
    {
        DEBUG_FUNC(DBOBJSetRequest::getNodeAction)

        if (p_intCurAction==DBOBJaction_Unspec) return p_intParentAction;
        if (p_intCurAction==DBOBJaction_None) return DBOBJaction_None;
        else{
            switch(p_intParentAction)
            {
            case DBOBJaction_Unspec:
                    return p_intCurAction;
                    break;

            case DBOBJaction_None:
                    return p_intCurAction;
                    break;

            case DBOBJaction_Insert:
                    if ( p_intCurAction==DBOBJaction_Delete ) return DBOBJaction_None;
                    else return DBOBJaction_Insert;
                    break;

            case DBOBJaction_Update:
                    return p_intCurAction;
                    break;

            case DBOBJaction_Delete:
                    if ( p_intCurAction==DBOBJaction_Insert ) return DBOBJaction_None;
                    else return DBOBJaction_Delete;
                    break;
            }
        }

        return DBOBJaction_Unspec;
    }

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



END_XDFLENGINE_NS

---