xml_parser.cpp

功能：首先

                newNode = m_pDocRoot->appendChild(newNode);
        }
        else
        {       this->ChainTag.Empty();
                m_pDocRoot = newNode;
                m_plDomDocument->documentElement = m_pDocRoot;
        }

        // Update Current Node (cast operation)
        //
        CurrentNode = newNode;

        // Update information for this Node
        //
        this->Grab_Node_Informations(CurrentNode);

        return true;
}

bool XML_PARSER::_add_firstchild(MSXML::IXMLDOMNodePtr newNode)
{       // Create Reference Node for the Insertion
        //
        _variant_t NodeRef = (IUnknown *)CurrentNode->firstChild;

        // Attach the Node to the document
        //
        if(CurrentNode != NULL)
        {       if(Is_MSXML_Node(this->CurrentNode) != MSXML::NODE_ELEMENT) return false;
                this->ChainTag_Add( this->Get_CurrentTag() );
                newNode = CurrentNode->insertBefore(newNode,NodeRef);
        }
        else if(m_pDocRoot != NULL)
        {       if(Is_MSXML_Node(this->m_pDocRoot) != MSXML::NODE_ELEMENT) return false;
                this->ChainTag_Add( (CString)(const char*)m_pDocRoot->nodeName );
                newNode = m_pDocRoot->insertBefore(newNode,NodeRef);
        }
        else
        {       this->ChainTag.Empty();
                m_pDocRoot = newNode;
                m_plDomDocument->documentElement = m_pDocRoot;
        }

        // Update Current Node (cast operation)
        //
        CurrentNode = newNode;

        // Update information for this Node
        //
        this->Grab_Node_Informations(CurrentNode);

        return true;
}

bool XML_PARSER::_add_before(MSXML::IXMLDOMNodePtr newNode)
{ 
		if(this->Is_Root())
        {       lasterror = "XML_PARSER::_add_before()   : Can't add node at same level that the root node";
                return false;
        }

        // Create Reference Node for the Insertion
        //
        MSXML::IXMLDOMNodePtr pParent;
        this->CurrentNode->get_parentNode(&pParent);
        _variant_t NodeRef = (IUnknown *)CurrentNode;


        // Attach the Node to the document
        //
        if(CurrentNode != NULL)
                newNode = pParent->insertBefore(newNode,NodeRef);
        else if(m_pDocRoot != NULL)
                newNode = m_pDocRoot->insertBefore(newNode,NodeRef);
        else
        {       m_pDocRoot = newNode;
                m_plDomDocument->documentElement = m_pDocRoot;
        }

        // Update Current Node (cast operation)
        //
        CurrentNode = newNode;

        // Update information for this Node
        //
        this->Grab_Node_Informations(CurrentNode);

        return true;
}

bool XML_PARSER::_add_after(MSXML::IXMLDOMNodePtr newNode)
{       // If CurrentNode->NextSibling == NULL then must call Add_LastChildNode on Parent Node
        // Because we can't use InsertBefore on a NULL Reference ;o)
        //
        // We are sure that a Parent node exist because before we control that we aren't not on root node.
        //
        if(CurrentNode->nextSibling == NULL)
        {       // Get Parent Node
                //
                MSXML::IXMLDOMNodePtr pParent;
                this->CurrentNode->get_parentNode(&pParent);

                // Set Parent node as Current Node
                //
                this->CurrentNode = pParent;
                this->Grab_Node_Informations(pParent);

                // Add Node as Last Child Node
                //
                return (this->Add_LastChildNode(Name));
        }

        // Create Reference Node for the Insertion
        //
        MSXML::IXMLDOMNodePtr pParent;
        this->CurrentNode->get_parentNode(&pParent);
        _variant_t NodeRef = (IUnknown *)CurrentNode->nextSibling;


        // Attach the Node to the document
        //
        if(CurrentNode != NULL)
                newNode = pParent->insertBefore(newNode,NodeRef);
        else if(m_pDocRoot != NULL)
                newNode = m_pDocRoot->insertBefore(newNode,NodeRef);
        else
        {       m_pDocRoot = newNode;
                m_plDomDocument->documentElement = m_pDocRoot;
        }

        // Update Current Node (cast operation)
        //
        CurrentNode = newNode;

        // Update information for this Node
        //
        this->Grab_Node_Informations(CurrentNode);

        return true;
}

bool XML_PARSER::Add_LastChildCData(LPCTSTR data)
{
     // Nodes members
     //
     MSXML::IXMLDOMNodePtr newNode;

     CComVariant vType(MSXML::NODE_CDATA_SECTION);
     newNode = m_plDomDocument->createNode(vType,"","");

     // Attach the Node to the document
     //
     bool Result = this->_add_lastchild(newNode);
     this->Set_TextValue(data);
   
     return Result;
}

bool XML_PARSER::Add_FirstChildCData(LPCTSTR data)
{    // Nodes members
     //
     MSXML::IXMLDOMNodePtr newNode;

     // If no child then use Add_LastChildCData or CurrentElement node not set yet
     //
     if(this->CurrentNode != NULL)
     {  if( !this->CurrentNode->hasChildNodes() )
             return (this->Add_LastChildCData(data));
     }
     else
         return (this->Add_LastChildCData(data));

     // Create the NODE
     //
     CComVariant vType(MSXML::NODE_CDATA_SECTION);
     newNode = m_plDomDocument->createNode(vType,"","");
      

     bool Result = this->_add_firstchild(newNode);
     this->Set_TextValue(data);

     return Result;
}

bool XML_PARSER::Add_CDataBefore(LPCTSTR data)
{   // Nodes members
    // IXMLDOMElementPtr CurrentNode;        /* Global Member */
    //
    MSXML::IXMLDOMNodePtr newNode;

    // Can't use this function on the root node
    //
    if(this->Is_Root())
        return false;
        
    // Create the NODE
    //
    CComVariant vType(MSXML::NODE_CDATA_SECTION);
    newNode = m_plDomDocument->createNode(vType,"","");

    bool Result = this->_add_before(newNode);
    this->Set_TextValue(data);

    return Result;
}

bool XML_PARSER::Add_CDataAfter(LPCTSTR data)
{   // Nodes members
    //
    MSXML::IXMLDOMNodePtr newNode;

    // Can't use this function on the root node
    //
    if(this->Is_Root())
    {       lasterror = "XML_PARSER::Add_CDataAfter(LPCTSTR)   : Can't add node at same level that the root node";
            return false;
    }

    // Create the NODE
    //
    CComVariant vType(MSXML::NODE_CDATA_SECTION);
    newNode = m_plDomDocument->createNode(vType,"","");

    bool Result = this->_add_after(newNode);
    this->Set_TextValue(data);

    return Result;
}

bool XML_PARSER::Add_LastChildNode(LPCTSTR Name)
{
        // Nodes members
        //
        MSXML::IXMLDOMNodePtr newNode;

        // Create NODE TYPE
        //
        CComVariant vType(MSXML::NODE_ELEMENT);

        // Create the NODE
        //
        newNode = m_plDomDocument->createNode(vType,Name,"");

        // Attach the Node to the document
        //
        return this->_add_lastchild(newNode);
}

bool XML_PARSER::Add_NodeBefore(LPCTSTR Name)
{       // Nodes members
        // IXMLDOMElementPtr CurrentNode;        /* Global Member */
        //
        MSXML::IXMLDOMNodePtr newNode;

        // Can't use this function on the root node
        //
        if(this->Is_Root())
                return false;
        // Create NODE TYPE
        //
        CComVariant vType(MSXML::NODE_ELEMENT);

        // Create the NODE
        //
        newNode = m_plDomDocument->createNode(vType,Name,"");

        return this->_add_before(newNode);
}

bool XML_PARSER::Add_NodeAfter(LPCTSTR Name)
{       // Nodes members
        // IXMLDOMElementPtr CurrentNode;        /* Global Member */
        //
        MSXML::IXMLDOMNodePtr newNode;

        // Can't use this function on the root node
        //
        if(this->Is_Root())
        {       lasterror = "XML_PARSER::Add_NodeAfter(LPCTSTR)   : Can't add node at same level that the root node";
                return false;
        }

        // Create NODE TYPE
        //
        CComVariant vType(MSXML::NODE_ELEMENT);

        // Create the NODE
        //
        newNode = m_plDomDocument->createNode(vType,Name,"");

        return this->_add_after(newNode);
}

bool XML_PARSER::Add_FirstChildNode(LPCTSTR Name)
{       // Nodes members
        // IXMLDOMElementPtr CurrentNode;        /* Global Member */
        //
        MSXML::IXMLDOMNodePtr newNode;
        //IXMLDOMNodeListPtr ChildList;

        // If no child then use Add_LastChildNode or CurrentElement node not set yet
        //
        if(CurrentNode != NULL)
        { if( !this->CurrentNode->hasChildNodes() )
             return (this->Add_LastChildNode(Name));
        }
        else
          return (this->Add_LastChildNode(Name));

        // Create NODE TYPE
        //
        CComVariant vType(MSXML::NODE_ELEMENT);

        // Create the NODE
        //
        newNode = m_plDomDocument->createNode(vType,Name,"");

        return this->_add_firstchild(newNode);
}

bool XML_PARSER::Set_Attribute(LPCTSTR AttribName,LPCTSTR AttribValue)
{
        // Nodes members
        MSXML::IXMLDOMElementPtr CurrentElementNode = CurrentNode;

        // Create Attribute variable
        //
        CComVariant sAttribute(AttribValue);

        // Set the new attribute
        //
        if(CurrentNode != NULL)
        {
           CurrentElementNode->setAttribute( AttribName, sAttribute );
           CurrentNode = CurrentElementNode;
           this->Grab_Node_Informations(CurrentNode);
        }
        else
        {   m_pDocRoot->setAttribute( AttribName, sAttribute );
            this->Grab_Node_Informations(m_pDocRoot);
        }

        // Return
        //
        return true;
}

bool XML_PARSER::Remove_Attribute(LPCTSTR AttribName)
{
        if(CurrentNode == NULL)
        {       if(this->m_pDocRoot != NULL)
                        this->CurrentNode = this->m_pDocRoot;
                else
                {       lasterror = "XML_PARSER::Remove_Attribute(LPCTSTR)   : Can't remove attribute on a NULL Node";
                        return false;
                }
        }

        MSXML::IXMLDOMElementPtr CurrentElementNode = CurrentNode;
        CurrentElementNode->removeAttribute(AttribName);
        CurrentNode = CurrentElementNode;

        return true;
}

bool XML_PARSER::Set_TextValue(LPCTSTR TextValue)
{
        // Nodes members
        // IXMLDOMElementPtr CurrentNode;        /* Global Member */
        //
        MSXML::IXMLDOMNodePtr newNode;

        // Find if a CHILD TEXT NODE exist or not
        //
        if(CurrentNode == NULL)
        {       if(this->m_pDocRoot != NULL)
                        this->CurrentNode = this->m_pDocRoot;
                else
                {       lasterror = "XML_PARSER::Set_TextValue(LPCTSTR)   : Can't set a Text on a NULL Node";
                        return false;
                }
        }

        if(this->Is_MSXML_Node(this->CurrentNode) == MSXML::NODE_CDATA_SECTION)
        {
           CComVariant sValue(TextValue);
           this->CurrentNode->put_nodeValue(sValue);

           return true;
        }

        // Rq: a NODE_CDATA_SECTION can't have any childs
        //
        if(this->CurrentNode->hasChildNodes())
        {
                MSXML::IXMLDOMNodePtr pChild;
                for(pChild = this->CurrentNode->firstChild; pChild != NULL; pChild = pChild->nextSibling)
                {       // Find it's a NODE TEXT
                        //
                        if(this->Is_MSXML_Node(pChild) == MSXML::NODE_TEXT)
                        {  // A Text Node is found, Replace it now!!
                           //
                           CComVariant sValue(TextValue);
                           pChild->put_nodeValue(sValue);
   
                           return true;
                        }
                }
        }

        // No previous Text was defined before, we can add it.
        //
        if(this->Is_MSXML_Node(this->CurrentNode) == MSXML::NODE_ELEMENT)
        {   // Create NODE TEXT type
            //
            CComVariant vType(MSXML::NODE_TEXT);

            // Create the node
            //
            newNode = m_plDomDocument->createTextNode(TextValue);

           // Attach the Node to the document
           //
           newNode = CurrentNode->appendChild(newNode);
        }

        return true;
}

bool XML_PARSER::Save_XML_Document(LPCTSTR strFileName)
{       // Save the XML document
        //
        m_plDomDocument->save(strFileName);

        // Return
        //
        return true;
}

void XML_PARSER::Reset_XML_Document()
{
        // Init
        //
        this->Init_MSXML();
        m_plDomDocument->loadXML("");
        m_pDocRoot = m_plDomDocument->documentElement;
        CurrentNode = NULL;

        // Init our members
        //
        this->AttribNames.RemoveAll();
        this->AttribValues.RemoveAll();
        this->Tag.Empty();
        this->Name.Empty();
        this->ChainTag.Empty();
        this->TextField.Empty();
        attrib_index = -1;
}

void XML_PARSER::Go_to_Root()
{ 
  attrib_index = -1;
  this->CurrentNode = this->m_pDocRoot;
  this->ChainTag.Empty();
}

bool XML_PARSER::Go_to_Child()
{       // Child node
        //
        MSXML::IXMLDOMNodePtr pChild;

        if(Is_MSXML_Node(this->CurrentNode) != MSXML::NODE_ELEMENT)
                return false;

        pChild = CurrentNode->firstChild;
        if(pChild == NULL) return false;
                
        // Grab Information from Child node
        //
        attrib_index = -1;
        ChainTag_Add(this->Get_CurrentTag());
        this->Grab_Node_Informations(pChild);

        this->CurrentNode = pChild;
        return true;
}

bool XML_PARSER::Go_to_Parent()
{       // Parent node
        //
        MSXML::IXMLDOMNodePtr pParent = NULL;

        if(this->CurrentNode == this->m_pDocRoot)
                return false;

        this->CurrentNode->get_parentNode(&pParent);
        this->CurrentNode = pParent;

        attrib_index = -1;
        this->ChainTag_Remove(1);
        this->Grab_Node_Informations(this->CurrentNode);
        return true;
}