Changeset 48779 in vbox for trunk/src/VBox/Runtime/r3/xml.cpp

Timestamp:

Oct 1, 2013 2:14:13 AM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

89417

Message:

iprt/xml.h: Replaced std::list<shared_ptr<>> with RTList both to safe a bunch of heap allocations but more importantly to improve enumerability of the XML tree. Added some new methods too, both related to enumeration and to other things. Note: If we can get rid of the shared_ptr stuff with attributes we can jettison the boost dependency we have, AFAICT.

File:

• trunk/src/VBox/Runtime/r3/xml.cpp (modified) (22 diffs)

trunk/src/VBox/Runtime/r3/xml.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2007-2012 Oracle Corporation
+ * Copyright (C) 2007-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -25 +25 @@
  */
 
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #include <iprt/dir.h>
 #include <iprt/file.h>
@@ -43 +47 @@
 
 #include <map>
-#include <boost/shared_ptr.hpp>
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// globals
-//
-////////////////////////////////////////////////////////////////////////////////
-
+#include <boost/shared_ptr.hpp> /* This is the ONLY use of boost. */
+
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
 /**
  * Global module initialization structure. This is to wrap non-reentrant bits
@@ -59 +61 @@
  * this structure.
  */
-static
-class Global
+static class Global
 {
 public:
@@ -94 +95 @@
     }
     sxml;  /* XXX naming this xml will break with gcc-3.3 */
-}
-gGlobal;
+} gGlobal;
 
 
@@ -132 +132 @@
  * returned string using RTStrFree() when no more necessary.
  */
-// static
-char *XmlError::Format(xmlErrorPtr aErr)
+/* static */ char *XmlError::Format(xmlErrorPtr aErr)
 {
     const char *msg = aErr->message ? aErr->message : "<none>";
@@ -443 +442 @@
     AttributesMap attribs;
 
+#ifdef USE_STD_LIST_FOR_CHILDREN
     // child elements, if this is an element; can be empty
     typedef std::list< boost::shared_ptr<Node> > InternalNodesList;
     InternalNodesList children;
+#endif
 };
 
@@ -452 +453 @@
            xmlNode *plibNode,
            xmlAttr *plibAttr)
-    : m_Type(type),
-      m_pParent(pParent),
-      m_plibNode(plibNode),
-      m_plibAttr(plibAttr),
-      m_pcszNamespacePrefix(NULL),
-      m_pcszNamespaceHref(NULL),
-      m_pcszName(NULL),
-      m(new Data)
-{
+    : m_Type(type)
+    , m_pParent(pParent)
+    , m_plibNode(plibNode)
+    , m_plibAttr(plibAttr)
+    , m_pcszNamespacePrefix(NULL)
+    , m_pcszNamespaceHref(NULL)
+    , m_pcszName(NULL)
+    , m(new Data)
+{
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    RTListInit(&m_childEntry);
+    RTListInit(&m_children);
+#endif
 }
 
 Node::~Node()
 {
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    Node *pCur, *pNext;
+    RTListForEachSafe(&m_children, pCur, pNext, Node, m_childEntry)
+    {
+        delete pCur;
+    }
+    RTListInit(&m_children);
+#endif
     delete m;
 }
@@ -487 +500 @@
 
     // go thru this element's child elements
-    xmlNodePtr plibNode = m_plibNode->children;
-    while (plibNode)
-    {
+    for (xmlNodePtr plibNode = m_plibNode->children; plibNode; plibNode = plibNode->next)
+    {
+#ifndef USE_STD_LIST_FOR_CHILDREN
+        Node *pNew;
+        if (plibNode->type == XML_ELEMENT_NODE)
+            pNew = new ElementNode(&elmRoot, this, plibNode);
+        else if (plibNode->type == XML_TEXT_NODE)
+            pNew = new ContentNode(this, plibNode);
+        else
+            continue;
+        RTListAppend(&m_children, &pNew->m_childEntry);
+
+        /* Recurse for this child element to get its own children. */
+        pNew->buildChildren(elmRoot);
+#else
         boost::shared_ptr<Node> pNew;
 
@@ -504 +529 @@
             pNew->buildChildren(elmRoot);
         }
-
-        plibNode = plibNode->next;
+#endif
     }
 }
@@ -567 +591 @@
 
 /**
+ * Variant of nameEquals that checks the namespace as well.
+ *
+ * @return  true if equal, false if not.
+ * @param   pcszNamespace   The name space prefix or NULL.
+ * @param   pcsz            The element name.
+ * @param   cchMax          The maximum number of character from @a pcsz to
+ *                          match.
+ */
+bool Node::nameEqualsN(const char *pcszNamespace, const char *pcsz, size_t cchMax) const
+{
+    /* Match the name. */
+    if (!m_pcszName)
+        return false;
+    if (!pcsz || cchMax == 0)
+        return false;
+    if (strncmp(m_pcszName, pcsz, cchMax))
+        return false;
+    if (strlen(m_pcszName) > cchMax)
+        return false;
+
+    /* Match name space. */
+    if (!pcszNamespace)
+        return true;    /* NULL, anything goes. */
+    if (!m_pcszNamespacePrefix)
+        return false;   /* Element has no namespace. */
+    return !strcmp(m_pcszNamespacePrefix, pcszNamespace);
+}
+
+/**
  * Returns the value of a node. If this node is an attribute, returns
  * the attribute value; if this node is an element, then this returns
@@ -572 +625 @@
  * @return
  */
-const char* Node::getValue() const
-{
-    if (    (m_plibAttr)
-         && (m_plibAttr->children)
-       )
+const char *Node::getValue() const
+{
+    if (   m_plibAttr
+        && m_plibAttr->children
+        )
         // libxml hides attribute values in another node created as a
         // single child of the attribute node, and it's in the content field
-        return (const char*)m_plibAttr->children->content;
-
-    if (    (m_plibNode)
-         && (m_plibNode->children)
-       )
-        return (const char*)m_plibNode->children->content;
+        return (const char *)m_plibAttr->children->content;
+
+    if (   m_plibNode
+        && m_plibNode->children)
+        return (const char *)m_plibNode->children->content;
 
     return NULL;
@@ -710 +762 @@
 {
     int i = 0;
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    Node *p;
+    RTListForEach(&m_children, p, Node, m_childEntry)
+#else
     for (Data::InternalNodesList::iterator it = m->children.begin();
          it != m->children.end();
          ++it)
+#endif
     {
         // export this child node if ...
+#ifdef USE_STD_LIST_FOR_CHILDREN
         Node *p = it->get();
+#endif
         if (p->isElement())
-            if (    (!pcszMatch)    // the caller wants all nodes or
-                 || (!strcmp(pcszMatch, p->getName())) // the element name matches
+            if (   !pcszMatch                       // ... the caller wants all nodes or ...
+                || !strcmp(pcszMatch, p->getName()) // ... the element name matches.
                )
             {
-                children.push_back(static_cast<ElementNode*>(p));
+                children.push_back(static_cast<ElementNode *>(p));
                 ++i;
             }
@@ -735 +794 @@
  * @return
  */
-const ElementNode* ElementNode::findChildElement(const char *pcszNamespace,
-                                                 const char *pcszMatch)
-    const
-{
+const ElementNode *ElementNode::findChildElement(const char *pcszNamespace, const char *pcszMatch) const
+{
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    Node *p;
+    RTListForEach(&m_children, p, Node, m_childEntry)
+    {
+        if (p->isElement())
+        {
+            ElementNode *pelm = static_cast<ElementNode*>(p);
+            if (pelm->nameEquals(pcszNamespace, pcszMatch))
+                return pelm;
+        }
+    }
+#else
     Data::InternalNodesList::const_iterator
         it,
         last = m->children.end();
-    for (it = m->children.begin();
-         it != last;
-         ++it)
-    {
+    for (it = m->children.begin(); it != last; ++it)
         if ((**it).isElement())
         {
@@ -752 +818 @@
                 return pelm;
         }
-    }
+#endif
 
     return NULL;
@@ -762 +828 @@
  * @return child element or NULL if not found.
  */
-const ElementNode* ElementNode::findChildElementFromId(const char *pcszId) const
-{
+const ElementNode * ElementNode::findChildElementFromId(const char *pcszId) const
+{
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    Node *p;
+    RTListForEach(&m_children, p, Node, m_childEntry)
+    {
+        if (p->isElement())
+        {
+            ElementNode *pelm = static_cast<ElementNode*>(p);
+            const AttributeNode *pAttr = pelm->findAttribute("id");
+            if (pAttr && !strcmp(pAttr->getValue(), pcszId))
+                return pelm;
+        }
+    }
+#else
     Data::InternalNodesList::const_iterator
         it,
@@ -781 +860 @@
         }
     }
+#endif
+    return NULL;
+}
+
+/**
+ * Recursively find the first matching child element.
+ *
+ * @returns child element or NULL if not found.
+ * @param   pcszNamespace   The Namespace prefix or NULL.
+ * @param   pcszPath        Simple element path, with parent and child elements
+ *                          separated by a forward slash ('/').
+ */
+const ElementNode *ElementNode::findChildElementDeep(const char *pcszNamespace, const char *pcszPath) const
+{
+    size_t cchThis = strchr(pcszPath, '/') - pcszPath;
+    if (cchThis == (const char *)0 - pcszPath)
+        return this->findChildElement(pcszNamespace, pcszPath);
+
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    /** @todo Can be done without recursion as we have both sibling lists and parent
+     *        pointers in this variant.  */
+    Node *p;
+    RTListForEach(&m_children, p, Node, m_childEntry)
+    {
+        if (p->isElement())
+        {
+            const ElementNode *pElm = static_cast<ElementNode*>(p);
+            if (pElm->nameEqualsN(pcszNamespace, pcszPath, cchThis))
+            {
+                pElm = findChildElementDeep(pcszNamespace, pcszPath + cchThis);
+                if (pElm)
+                    return pElm;
+            }
+        }
+    }
+#else
+    Data::InternalNodesList::const_iterator  itLast = m->children.end();
+    for (Data::InternalNodesList::const_iterator it = m->children.begin(); it != itLast; ++it)
+    {
+        if ((**it).isElement())
+        {
+            const ElementNode *pElm = static_cast<ElementNode*>((*it).get());
+            if (pElm->nameEqualsN(pcszNamespace, pcszPath, cchThis))
+            {
+                pElm = findChildElementDeep(pcszNamespace, pcszPath + cchThis);
+                if (pElm)
+                    return pElm;
+            }
+        }
+    }
+#endif
 
     return NULL;
@@ -1001 +1131 @@
  * @return
  */
-ElementNode* ElementNode::createChild(const char *pcszElementName)
+ElementNode *ElementNode::createChild(const char *pcszElementName)
 {
     // we must be an element, not an attribute
@@ -1016 +1146 @@
     // now wrap this in C++
     ElementNode *p = new ElementNode(m_pelmRoot, this, plibNode);
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    RTListAppend(&m_children, &p->m_childEntry);
+#else
     boost::shared_ptr<ElementNode> pNew(p);
     m->children.push_back(pNew);
+#endif
 
     return p;
@@ -1030 +1164 @@
  * @return
  */
-ContentNode* ElementNode::addContent(const char *pcszContent)
+ContentNode *ElementNode::addContent(const char *pcszContent)
 {
     // libxml side: create new node
-    xmlNode *plibNode;
-    if (!(plibNode = xmlNewText((const xmlChar*)pcszContent)))
+    xmlNode *plibNode = xmlNewText((const xmlChar*)pcszContent);
+    if (!plibNode)
         throw std::bad_alloc();
     xmlAddChild(m_plibNode, plibNode);
@@ -1040 +1174 @@
     // now wrap this in C++
     ContentNode *p = new ContentNode(this, plibNode);
+#ifndef USE_STD_LIST_FOR_CHILDREN
+    RTListAppend(&m_children, &p->m_childEntry);
+#else
     boost::shared_ptr<ContentNode> pNew(p);
     m->children.push_back(pNew);
+#endif
 
     return p;
@@ -1501 +1639 @@
  * The document that is passed in will be reset before being filled if not empty.
  *
- * @param pvBuf in: memory buffer to parse.
- * @param cbSize in: size of the memory buffer.
- * @param strFilename in: name fo file to parse.
- * @param doc out: document to be reset and filled with data according to file contents.
- */
-void XmlMemParser::read(const void* pvBuf, size_t cbSize,
+ * @param pvBuf         Memory buffer to parse.
+ * @param cbSize        Size of the memory buffer.
+ * @param strFilename   Refernece to the name of the file we're parsing.
+ * @param doc           Reference to the output document.  This will be reset
+ *                      and filled with data according to file contents.
+ */
+void XmlMemParser::read(const void *pvBuf, size_t cbSize,
                         const RTCString &strFilename,
                         Document &doc)