Bug 12071 fixed: Printed info of a XML object were inconsistent with available fields 96/9696/2
Calixte DENIZET [Wed, 14 Nov 2012 13:14:38 +0000 (14:14 +0100)]
Change-Id: I4de2a29a9d9c9502a405df8d07dc7d9436b003bf

scilab/CHANGES_5.4.X
scilab/modules/xml/src/cpp/XMLAttr.cpp
scilab/modules/xml/src/cpp/XMLAttr.hxx
scilab/modules/xml/src/cpp/XMLDocument.cpp
scilab/modules/xml/src/cpp/XMLElement.cpp
scilab/modules/xml/src/cpp/XMLNodeList.cpp
scilab/modules/xml/src/cpp/XMLNodeList.hxx
scilab/modules/xml/tests/unit_tests/xmlName.dia.ref

index 6d14c75..fdc5090 100644 (file)
@@ -96,6 +96,9 @@ Bug fixes
 
 * Bug #12050 fixed - Fix a typo: dimensionnal => dimensional.
 
+* Bug #12071 fixed - Printed info of a XML object were inconsistent with
+                     available fields.
+
 * Bug #12077 fixed - In help, attribute bgcolor was not handled in tables.
 
 
index d3bdbe3..0cc3d3a 100644 (file)
 
 namespace org_modules_xml
 {
-    XMLAttr::XMLAttr(const XMLElement & _elem):XMLObject(), elem(_elem)
-    {
-        scilabType = XMLATTRIBUTE;
-        id = scope->getVariableId(*this);
-        scope->registerPointers(elem.getRealNode()->properties, this);
-    }
+XMLAttr::XMLAttr(const XMLElement & _elem): XMLObject(), elem(_elem)
+{
+    scilabType = XMLATTRIBUTE;
+    id = scope->getVariableId(*this);
+    scope->registerPointers(elem.getRealNode()->properties, this);
+}
 
-    XMLAttr::~XMLAttr()
+XMLAttr::~XMLAttr()
+{
+    scope->unregisterPointer(elem.getRealNode()->properties);
+    scope->removeId(id);
+}
+
+void *XMLAttr::getRealXMLPointer() const
+{
+    return static_cast < void *>(elem.getRealNode()->properties);
+}
+
+const XMLObject *XMLAttr::getXMLObjectParent() const
+{
+    return &elem;
+}
+
+const char *XMLAttr::getAttributeValue(const char *name) const
+{
+    xmlNode *node = elem.getRealNode();
+    xmlAttr *attrs = xmlHasProp(node, (const xmlChar *)name);
+    if (attrs)
     {
-        scope->unregisterPointer(elem.getRealNode()->properties);
-        scope->removeId(id);
+        return (const char *)attrs->children->content;
     }
 
-    void *XMLAttr::getRealXMLPointer() const
+    return 0;
+}
+
+const char *XMLAttr::getAttributeValue(const char *ns, const char *name) const
+{
+    xmlNode *node = elem.getRealNode();
+    xmlAttr *attrs = 0;
+    for (xmlAttr * cur = node->properties; cur; cur = cur->next)
     {
-        return static_cast < void *>(elem.getRealNode()->properties);
+        if (cur->ns && !strcmp(name, (const char *)cur->name)
+                && (!strcmp(ns, (const char *)cur->ns->prefix) || !strcmp(ns, (const char *)cur->ns->href)))
+        {
+            attrs = cur;
+            break;
+        }
     }
 
-    const XMLObject *XMLAttr::getXMLObjectParent() const
+    if (attrs)
     {
-        return &elem;
+        return (const char *)attrs->children->content;
     }
 
-    const char *XMLAttr::getAttributeValue(const char *name) const
+    return 0;
+}
+
+const char *XMLAttr::getAttributeValue(int index) const
+{
+    xmlNode *node = elem.getRealNode();
+    int i = 1;
+    for (xmlAttr * cur = node->properties; cur; cur = cur->next, i++)
     {
-        xmlNode *node = elem.getRealNode();
-        xmlAttr *attrs = xmlHasProp(node, (const xmlChar *)name);
-        if (attrs)
+        if (i == index)
         {
-            return (const char *)attrs->children->content;
+            return (const char *)cur->children->content;
         }
-
-        return 0;
     }
 
-    const char *XMLAttr::getAttributeValue(const char *ns, const char *name) const
+    return 0;
+}
+
+void XMLAttr::setAttributeValue(const char *prefix, const char *name, const char *value) const
+{
+    setAttributeValue(elem.getRealNode(), prefix, name, value);
+}
+
+void XMLAttr::setAttributeValue(xmlNode * node, const char *prefix, const char *name, const char *value)
+{
+    if (node && node->type == XML_ELEMENT_NODE)
     {
-        xmlNode *node = elem.getRealNode();
         xmlAttr *attrs = 0;
+
         for (xmlAttr * cur = node->properties; cur; cur = cur->next)
         {
             if (cur->ns && !strcmp(name, (const char *)cur->name)
-                && (!strcmp(ns, (const char *)cur->ns->prefix) || !strcmp(ns, (const char *)cur->ns->href)))
+                    && (!strcmp(prefix, (const char *)cur->ns->prefix) || !strcmp(prefix, (const char *)cur->ns->href)))
             {
                 attrs = cur;
                 break;
@@ -72,200 +116,164 @@ namespace org_modules_xml
 
         if (attrs)
         {
-            return (const char *)attrs->children->content;
+            xmlSetNsProp(node, attrs->ns, (const xmlChar *)name, (const xmlChar *)value);
         }
-
-        return 0;
-    }
-
-    const char *XMLAttr::getAttributeValue(int index) const
-    {
-        xmlNode *node = elem.getRealNode();
-        int i = 1;
-        for (xmlAttr * cur = node->properties; cur; cur = cur->next, i++)
+        else
         {
-            if (i == index)
+            xmlNs *ns = 0;
+
+            if (!strncmp(prefix, "http://", strlen("http://")))
             {
-                return (const char *)cur->children->content;
+                ns = xmlSearchNsByHref(node->doc, node, (const xmlChar *)prefix);
             }
-        }
-
-        return 0;
-    }
-
-    void XMLAttr::setAttributeValue(const char *prefix, const char *name, const char *value) const
-    {
-        setAttributeValue(elem.getRealNode(), prefix, name, value);
-    }
-
-    void XMLAttr::setAttributeValue(xmlNode * node, const char *prefix, const char *name, const char *value)
-    {
-        if (node && node->type == XML_ELEMENT_NODE)
-        {
-            xmlAttr *attrs = 0;
-
-            for (xmlAttr * cur = node->properties; cur; cur = cur->next)
+            else
             {
-                if (cur->ns && !strcmp(name, (const char *)cur->name)
-                    && (!strcmp(prefix, (const char *)cur->ns->prefix) || !strcmp(prefix, (const char *)cur->ns->href)))
-                {
-                    attrs = cur;
-                    break;
-                }
+                ns = xmlSearchNs(node->doc, node, (const xmlChar *)prefix);
             }
 
-            if (attrs)
+            if (ns)
             {
-                xmlSetNsProp(node, attrs->ns, (const xmlChar *)name, (const xmlChar *)value);
+                xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
             }
             else
             {
-                xmlNs *ns = 0;
-
-                if (!strncmp(prefix, "http://", strlen("http://")))
-                {
-                    ns = xmlSearchNsByHref(node->doc, node, (const xmlChar *)prefix);
-                }
-                else
-                {
-                    ns = xmlSearchNs(node->doc, node, (const xmlChar *)prefix);
-                }
-
-                if (ns)
-                {
-                    xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
-                }
-                else
-                {
-                    xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
-                }
-            }
-        }
-    }
-
-    void XMLAttr::setAttributeValue(xmlNode * node, const char **prefix, const char **name, const char **value, int size)
-    {
-        if (node && node->type == XML_ELEMENT_NODE)
-        {
-            for (int i = 0; i < size; i++)
-            {
-                setAttributeValue(node, prefix[i], name[i], value[i]);
+                xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
             }
         }
     }
+}
 
-    void XMLAttr::setAttributeValue(const char **prefix, const char **name, const char **value, int size) const
+void XMLAttr::setAttributeValue(xmlNode * node, const char **prefix, const char **name, const char **value, int size)
+{
+    if (node && node->type == XML_ELEMENT_NODE)
     {
         for (int i = 0; i < size; i++)
         {
-            setAttributeValue(prefix[i], name[i], value[i]);
+            setAttributeValue(node, prefix[i], name[i], value[i]);
         }
     }
+}
 
-    void XMLAttr::setAttributeValue(int index, const char *value) const
+void XMLAttr::setAttributeValue(const char **prefix, const char **name, const char **value, int size) const
+{
+    for (int i = 0; i < size; i++)
     {
-        setAttributeValue(elem.getRealNode(), index, value);
+        setAttributeValue(prefix[i], name[i], value[i]);
     }
+}
+
+void XMLAttr::setAttributeValue(int index, const char *value) const
+{
+    setAttributeValue(elem.getRealNode(), index, value);
+}
 
-    void XMLAttr::setAttributeValue(xmlNode * node, int index, const char *value)
+void XMLAttr::setAttributeValue(xmlNode * node, int index, const char *value)
+{
+    if (node && node->type == XML_ELEMENT_NODE)
     {
-        if (node && node->type == XML_ELEMENT_NODE)
-        {
-            int i = 1;
+        int i = 1;
 
-            for (xmlAttr * cur = node->properties; cur; cur = cur->next, i++)
+        for (xmlAttr * cur = node->properties; cur; cur = cur->next, i++)
+        {
+            if (i == index)
             {
-                if (i == index)
-                {
-                    cur->children->content = xmlStrdup((const xmlChar *)value);
-                }
+                cur->children->content = xmlStrdup((const xmlChar *)value);
             }
         }
     }
+}
 
-    void XMLAttr::setAttributeValue(const char *name, const char *value) const
-    {
-        setAttributeValue(elem.getRealNode(), name, value);
-    }
+void XMLAttr::setAttributeValue(const char *name, const char *value) const
+{
+    setAttributeValue(elem.getRealNode(), name, value);
+}
 
-    void XMLAttr::setAttributeValue(xmlNode * node, const char *name, const char *value)
+void XMLAttr::setAttributeValue(xmlNode * node, const char *name, const char *value)
+{
+    if (node && node->type == XML_ELEMENT_NODE)
     {
-        if (node && node->type == XML_ELEMENT_NODE)
-        {
-            xmlAttr *attrs = xmlHasProp(node, (const xmlChar *)name);
+        xmlAttr *attrs = xmlHasProp(node, (const xmlChar *)name);
 
-            if (attrs)
-            {
-                xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
-            }
-            else
-            {
-                xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value);
-            }
+        if (attrs)
+        {
+            xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
         }
-    }
-
-    void XMLAttr::setAttributeValue(xmlNode * node, const char **name, const char **value, int size)
-    {
-        if (node && node->type == XML_ELEMENT_NODE)
+        else
         {
-            for (int i = 0; i < size; i++)
-            {
-                setAttributeValue(node, name[i], value[i]);
-            }
+            xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value);
         }
     }
+}
 
-    void XMLAttr::setAttributeValue(const char **name, const char **value, int size) const
+void XMLAttr::setAttributeValue(xmlNode * node, const char **name, const char **value, int size)
+{
+    if (node && node->type == XML_ELEMENT_NODE)
     {
         for (int i = 0; i < size; i++)
         {
-            setAttributeValue(name[i], value[i]);
+            setAttributeValue(node, name[i], value[i]);
         }
     }
+}
 
-    int XMLAttr::getSize() const
+void XMLAttr::setAttributeValue(const char **name, const char **value, int size) const
+{
+    for (int i = 0; i < size; i++)
     {
-        int i = 0;
-        for (xmlAttr * cur = elem.getRealNode()->properties; cur; cur = cur->next, i++) ;
-
-          return i;
+        setAttributeValue(name[i], value[i]);
     }
+}
 
-    const std::string XMLAttr::toString() const
+int XMLAttr::getSize() const
+{
+    return getSize(elem.getRealNode()->properties);
+}
+
+int XMLAttr::getSize(xmlAttr * attr)
+{
+    int i = 0;
+    for (xmlAttr * cur = attr; cur; cur = cur->next, i++)
     {
-        std::ostringstream oss;
-        xmlNode *node = elem.getRealNode();
+        ;
+    }
 
-          oss << "XML Attributes" << std::endl;
-        for (xmlAttr * cur = node->properties; cur; cur = cur->next)
-        {
-            if (cur->ns)
-            {
-                oss << cur->ns->prefix << ":" << cur->name << " --> " << cur->children->content << std::endl;
-            }
-            else
-            {
-                oss << cur->name << " --> " << cur->children->content << std::endl;
-            }
-        }
+    return i;
+}
 
-        return oss.str();
-    }
+const std::string XMLAttr::toString() const
+{
+    std::ostringstream oss;
+    xmlNode *node = elem.getRealNode();
 
-    const char ** XMLAttr::getNames() const
+    oss << "XML Attributes" << std::endl;
+    for (xmlAttr * cur = node->properties; cur; cur = cur->next)
     {
-        int size = getSize();
-        int i = 0;
-        char ** arr = new char*[size + 1];
-        xmlNode * node = elem.getRealNode();
-
-        for (xmlAttr * cur = node->properties; cur; cur = cur->next, i++)
+        if (cur->ns)
+        {
+            oss << cur->ns->prefix << ":" << cur->name << " --> " << cur->children->content << std::endl;
+        }
+        else
         {
-            arr[i] = (char *)cur->name;
+            oss << cur->name << " --> " << cur->children->content << std::endl;
         }
-        arr[size] = 0;
+    }
+
+    return oss.str();
+}
+
+const char ** XMLAttr::getNames() const
+{
+    int size = getSize();
+    int i = 0;
+    char ** arr = new char*[size + 1];
+    xmlNode * node = elem.getRealNode();
 
-        return const_cast<const char**>(arr);
+    for (xmlAttr * cur = node->properties; cur; cur = cur->next, i++)
+    {
+        arr[i] = (char *)cur->name;
     }
+    arr[size] = 0;
+
+    return const_cast<const char**>(arr);
+}
 }
index bce8f8d..43c2d35 100644 (file)
 
 namespace org_modules_xml
 {
-    class XMLElement;
-    class XMLObject;
+class XMLElement;
+class XMLObject;
 
-    class XML_SCILAB_IMPEXP XMLAttr : public XMLObject
-    {
-        const XMLElement & elem;
+class XML_SCILAB_IMPEXP XMLAttr : public XMLObject
+{
+    const XMLElement & elem;
 
 public:
-        /**
-         * Default constructor
-         * @param elem the element which has this attributes
-         */
-          XMLAttr(const XMLElement & elem);
-
-         ~XMLAttr();
-
-        void *getRealXMLPointer() const;
-
-        /**
-         * Get the number of attributes
-         * @return the attributes number
-         */
-        int getSize() const;
-
-        /**
-         * Gets the attribute value with the given index.
-         * @param index the attribute index
-         * @return the attribute value
-         */
-        const char *getAttributeValue(int index) const;
-
-        /**
-         * Gets the attribute value.
-         * @param name the attribute name
-         * @return the attribute value
-         */
-        const char *getAttributeValue(const char *name) const;
-
-        /**
-         * Gets the attribute value with a prefix namespace.
-         * @param prefix the namespace prefix or the namespace itself
-         * @param name the attribute name
-         * @return the attribute value
-         */
-        const char *getAttributeValue(const char *prefix, const char *name) const;
-
-        /**
-         * Sets the attribute value.
-         * @param name the attribute name
-         * @param value the attribute value
-         */
-        void setAttributeValue(const char *name, const char *value) const;
-
-        /**
-         * Sets the attribute value.
-         * @param node the node where to set the attributes
-         * @param name the attribute name
-         * @param value the attribute value
-         */
-        static void setAttributeValue(xmlNode * node, const char *name, const char *value);
-
-        /**
-         * Sets the attribute value.
-         * @param name the attribute names
-         * @param value the attribute values
-         * @param size the number of names
-         */
-        void setAttributeValue(const char **name, const char **value, int size) const;
-
-        /**
-         * Sets the attribute value.
-         * @param node the node where to set the attributes
-         * @param name the attribute names
-         * @param value the attribute values
-         * @param size the number of names
-         */
-        static void setAttributeValue(xmlNode * node, const char **name, const char **value, int size);
-
-        /**
-         * Sets the attribute value at the given index.
-         * @param index the attribute index
-         * @param value the attribute value
-         */
-        void setAttributeValue(int index, const char *value) const;
-
-        /**
-         * Sets the attribute value at the given index.
-         * @param node the node where to set the attributes
-         * @param index the attribute index
-         * @param value the attribute value
-         */
-        static void setAttributeValue(xmlNode * node, int index, const char *value);
-
-        /**
-         * Sets the attribute value with a prefix namespace.
-         * @param prefix the namespace prefix or the namespace itself
-         * @param name the attribute name
-         * @param value the attribute value
-         */
-        void setAttributeValue(const char *prefix, const char *name, const char *value) const;
-
-        /**
-         * Sets the attribute value with a prefix namespace.
-         * @param node the node where to set the attributes
-         * @param prefix the namespace prefix or the namespace itself
-         * @param name the attribute name
-         * @param value the attribute value
-         */
-        static void setAttributeValue(xmlNode * node, const char *prefix, const char *name, const char *value);
-
-        /**
-         * Sets the attribute value with a prefix namespace.
-         * @param prefix the namespace prefix or the namespace itself
-         * @param name the attribute names
-         * @param value the attribute values
-         * @param size the number of names
-         */
-        void setAttributeValue(const char **prefix, const char **name, const char **value, int size) const;
-
-        /**
-         * Sets the attribute value with a prefix namespace.
-         * @param node the node where to set the attributes
-         * @param prefix the namespace prefix or the namespace itself
-         * @param name the attribute names
-         * @param value the attribute values
-         * @param size the number of names
-         */
-        static void setAttributeValue(xmlNode * node, const char **prefix, const char **name, const char **value, int size);
-
-        /**
-         * @return the names of the attributes
-         */
-        const char ** getNames() const;
-
-        /**
-         * Gets the element associated with this object
-         * @return the associated object
-         */
-        const XMLElement & getElement() const
-        {
-            return elem;
-        }
-
-        const XMLObject *getXMLObjectParent() const;
-        const std::string toString() const;
-    };
+    /**
+     * Default constructor
+     * @param elem the element which has this attributes
+     */
+    XMLAttr(const XMLElement & elem);
+
+    ~XMLAttr();
+
+    void *getRealXMLPointer() const;
+
+    /**
+     * Get the number of attributes
+     * @return the attributes number
+     */
+    int getSize() const;
+
+    /**
+     * Gets the attribute value with the given index.
+     * @param index the attribute index
+     * @return the attribute value
+     */
+    const char *getAttributeValue(int index) const;
+
+    /**
+     * Gets the attribute value.
+     * @param name the attribute name
+     * @return the attribute value
+     */
+    const char *getAttributeValue(const char *name) const;
+
+    /**
+     * Gets the attribute value with a prefix namespace.
+     * @param prefix the namespace prefix or the namespace itself
+     * @param name the attribute name
+     * @return the attribute value
+     */
+    const char *getAttributeValue(const char *prefix, const char *name) const;
+
+    /**
+     * Sets the attribute value.
+     * @param name the attribute name
+     * @param value the attribute value
+     */
+    void setAttributeValue(const char *name, const char *value) const;
+
+    /**
+     * Sets the attribute value.
+     * @param node the node where to set the attributes
+     * @param name the attribute name
+     * @param value the attribute value
+     */
+    static void setAttributeValue(xmlNode * node, const char *name, const char *value);
+
+    /**
+     * Sets the attribute value.
+     * @param name the attribute names
+     * @param value the attribute values
+     * @param size the number of names
+     */
+    void setAttributeValue(const char **name, const char **value, int size) const;
+
+    /**
+     * Sets the attribute value.
+     * @param node the node where to set the attributes
+     * @param name the attribute names
+     * @param value the attribute values
+     * @param size the number of names
+     */
+    static void setAttributeValue(xmlNode * node, const char **name, const char **value, int size);
+
+    /**
+     * Sets the attribute value at the given index.
+     * @param index the attribute index
+     * @param value the attribute value
+     */
+    void setAttributeValue(int index, const char *value) const;
+
+    /**
+     * Sets the attribute value at the given index.
+     * @param node the node where to set the attributes
+     * @param index the attribute index
+     * @param value the attribute value
+     */
+    static void setAttributeValue(xmlNode * node, int index, const char *value);
+
+    /**
+     * Sets the attribute value with a prefix namespace.
+     * @param prefix the namespace prefix or the namespace itself
+     * @param name the attribute name
+     * @param value the attribute value
+     */
+    void setAttributeValue(const char *prefix, const char *name, const char *value) const;
+
+    /**
+     * Sets the attribute value with a prefix namespace.
+     * @param node the node where to set the attributes
+     * @param prefix the namespace prefix or the namespace itself
+     * @param name the attribute name
+     * @param value the attribute value
+     */
+    static void setAttributeValue(xmlNode * node, const char *prefix, const char *name, const char *value);
+
+    /**
+     * Sets the attribute value with a prefix namespace.
+     * @param prefix the namespace prefix or the namespace itself
+     * @param name the attribute names
+     * @param value the attribute values
+     * @param size the number of names
+     */
+    void setAttributeValue(const char **prefix, const char **name, const char **value, int size) const;
+
+    /**
+     * Sets the attribute value with a prefix namespace.
+     * @param node the node where to set the attributes
+     * @param prefix the namespace prefix or the namespace itself
+     * @param name the attribute names
+     * @param value the attribute values
+     * @param size the number of names
+     */
+    static void setAttributeValue(xmlNode * node, const char **prefix, const char **name, const char **value, int size);
+
+    /**
+     * @return the names of the attributes
+     */
+    const char ** getNames() const;
+
+    /**
+     * Gets the element associated with this object
+     * @return the associated object
+     */
+    const XMLElement & getElement() const
+    {
+        return elem;
+    }
+
+    const XMLObject *getXMLObjectParent() const;
+    const std::string toString() const;
+
+    /**
+     * Get the number of attributes
+     * @return the attributes number
+     */
+    static int getSize(xmlAttr * attr);
+};
 }
 
 #endif
index 4d4a8fe..28fe176 100644 (file)
@@ -30,370 +30,371 @@ extern "C"
 namespace org_modules_xml
 {
 
-    std::string * XMLDocument::errorBuffer = 0;
-    std::string * XMLDocument::errorXPathBuffer = 0;
-    std::list < XMLDocument * >&XMLDocument::openDocs = *new std::list < XMLDocument * >();
+std::string * XMLDocument::errorBuffer = 0;
+std::string * XMLDocument::errorXPathBuffer = 0;
+std::list < XMLDocument * >&XMLDocument::openDocs = *new std::list < XMLDocument * >();
 
-    XMLDocument::XMLDocument(const char *path, bool validate, std::string * error):XMLObject()
-    {
-        char *expandedPath = expandPathVariable(const_cast<char *>(path));
-        if (expandedPath)
-        {
-            document = readDocument(const_cast<const char *>(expandedPath), validate, error);
-            FREE(expandedPath);
-            if (document)
-            {
-                openDocs.push_back(this);
-                scope->registerPointers(document, this);
-            }
-        }
-        else
-        {
-            document = 0;
-            *error = std::string(gettext("Invalid file name: ")) + std::string(path);
-        }
-
-        id = scope->getVariableId(*this);
-        scilabType = XMLDOCUMENT;
-    }
-
-    XMLDocument::XMLDocument(const std::string & xmlCode, bool validate, std::string * error):XMLObject()
+XMLDocument::XMLDocument(const char *path, bool validate, std::string * error): XMLObject()
+{
+    char *expandedPath = expandPathVariable(const_cast<char *>(path));
+    if (expandedPath)
     {
-        document = readDocument(xmlCode, validate, error);
+        document = readDocument(const_cast<const char *>(expandedPath), validate, error);
+        FREE(expandedPath);
         if (document)
         {
             openDocs.push_back(this);
+            scope->registerPointers(document, this);
         }
-        scope->registerPointers(document, this);
-        id = scope->getVariableId(*this);
-        scilabType = XMLDOCUMENT;
     }
-
-    XMLDocument::XMLDocument(char *uri, char *version):XMLObject()
+    else
     {
-        char *newUri = 0;
-        char *expandedPath = 0;
-
-        if (!version)
-        {
-            version = const_cast < char *>("1.0");
-        }
-        document = xmlNewDoc((xmlChar *) version);
-        openDocs.push_back(this);
-        scope->registerPointers(document, this);
-        id = scope->getVariableId(*this);
-        scilabType = XMLDOCUMENT;
+        document = 0;
+        *error = std::string(gettext("Invalid file name: ")) + std::string(path);
+    }
 
-        expandedPath = expandPathVariable(const_cast < char *>(uri));
+    id = scope->getVariableId(*this);
+    scilabType = XMLDOCUMENT;
+}
 
-        if (expandedPath)
-        {
-            newUri = (char *)xmlMalloc(sizeof(char *) * (strlen(expandedPath) + 1));
-            memcpy(newUri, expandedPath, sizeof(char) * (strlen(expandedPath) + 1));
-            document->URL = (xmlChar *) newUri;
-            FREE(expandedPath);
-        }
+XMLDocument::XMLDocument(const std::string & xmlCode, bool validate, std::string * error): XMLObject()
+{
+    document = readDocument(xmlCode, validate, error);
+    if (document)
+    {
+        openDocs.push_back(this);
     }
+    scope->registerPointers(document, this);
+    id = scope->getVariableId(*this);
+    scilabType = XMLDOCUMENT;
+}
 
-    XMLDocument::~XMLDocument()
+XMLDocument::XMLDocument(char *uri, char *version): XMLObject()
+{
+    char *newUri = 0;
+    char *expandedPath = 0;
+
+    if (!version)
     {
-        scope->unregisterPointer(document);
-        scope->removeId(id);
-        if (document)
-        {
-            openDocs.remove(this);
-            if (openDocs.size() == 0 && XMLValidation::getOpenValidationFiles().size() == 0)
-            {
-                resetScope();
-            }
-            xmlFreeDoc(document);
-        }
-        if (errorBuffer)
-        {
-            delete errorBuffer;
-            errorBuffer = 0;
-        }
-        if (errorXPathBuffer)
-        {
-            delete errorXPathBuffer;
-            errorXPathBuffer = 0;
-        }
+        version = const_cast < char *>("1.0");
     }
+    document = xmlNewDoc((xmlChar *) version);
+    openDocs.push_back(this);
+    scope->registerPointers(document, this);
+    id = scope->getVariableId(*this);
+    scilabType = XMLDOCUMENT;
 
-    void *XMLDocument::getRealXMLPointer() const
+    expandedPath = expandPathVariable(const_cast < char *>(uri));
+
+    if (expandedPath)
     {
-        return static_cast < void *>(document);
+        newUri = (char *)xmlMalloc(sizeof(char *) * (strlen(expandedPath) + 1));
+        memcpy(newUri, expandedPath, sizeof(char) * (strlen(expandedPath) + 1));
+        document->URL = (xmlChar *) newUri;
+        FREE(expandedPath);
     }
+}
 
-    const XMLXPath *XMLDocument::makeXPathQuery(const char *query, char **namespaces, int length, const XMLElement * e, std::string * error)
+XMLDocument::~XMLDocument()
+{
+    scope->unregisterPointer(document);
+    scope->removeId(id);
+    if (document)
     {
-        if (errorXPathBuffer)
+        openDocs.remove(this);
+        if (openDocs.size() == 0 && XMLValidation::getOpenValidationFiles().size() == 0)
         {
-            delete errorXPathBuffer;
+            resetScope();
         }
-        errorXPathBuffer = new std::string();
+        xmlFreeDoc(document);
+    }
+    if (errorBuffer)
+    {
+        delete errorBuffer;
+        errorBuffer = 0;
+    }
+    if (errorXPathBuffer)
+    {
+        delete errorXPathBuffer;
+        errorXPathBuffer = 0;
+    }
+}
 
-        xmlXPathContext *ctxt = xmlXPathNewContext(document);
+void *XMLDocument::getRealXMLPointer() const
+{
+    return static_cast < void *>(document);
+}
 
-        if (!ctxt)
-        {
-            errorXPathBuffer->append(gettext("Cannot create a parser context"));
-            *error = *errorXPathBuffer;
-            return 0;
-        }
+const XMLXPath *XMLDocument::makeXPathQuery(const char *query, char **namespaces, int length, const XMLElement * e, std::string * error)
+{
+    if (errorXPathBuffer)
+    {
+        delete errorXPathBuffer;
+    }
+    errorXPathBuffer = new std::string();
 
-        if (e)
-        {
-            ctxt->node = (xmlNode *) e->getRealXMLPointer();
-        }
+    xmlXPathContext *ctxt = xmlXPathNewContext(document);
 
-        if (namespaces)
-        {
-            for (int i = 0; i < length; i++)
-            {
-                xmlXPathRegisterNs(ctxt, (const xmlChar *)namespaces[i], (const xmlChar *)namespaces[i + length]);
-            }
-        }
+    if (!ctxt)
+    {
+        errorXPathBuffer->append(gettext("Cannot create a parser context"));
+        *error = *errorXPathBuffer;
+        return 0;
+    }
 
-        xmlSetStructuredErrorFunc(ctxt, XMLDocument::errorXPathFunction);
-        xmlXPathCompExpr *expr = xmlXPathCtxtCompile(ctxt, (const xmlChar *)query);
+    if (e)
+    {
+        ctxt->node = (xmlNode *) e->getRealXMLPointer();
+    }
 
-        if (!expr)
+    if (namespaces)
+    {
+        for (int i = 0; i < length; i++)
         {
-            xmlSetStructuredErrorFunc(ctxt, 0);
-            xmlXPathFreeContext(ctxt);
-            *error = *errorXPathBuffer;
-            return 0;
+            xmlXPathRegisterNs(ctxt, (const xmlChar *)namespaces[i], (const xmlChar *)namespaces[i + length]);
         }
+    }
 
-        xmlXPathObject *xpath = xmlXPathCompiledEval(expr, ctxt);
+    xmlSetStructuredErrorFunc(ctxt, XMLDocument::errorXPathFunction);
+    xmlXPathCompExpr *expr = xmlXPathCtxtCompile(ctxt, (const xmlChar *)query);
 
+    if (!expr)
+    {
         xmlSetStructuredErrorFunc(ctxt, 0);
         xmlXPathFreeContext(ctxt);
-        xmlXPathFreeCompExpr(expr);
-        if (!xpath)
-        {
-            *error = *errorXPathBuffer;
-            return 0;
-        }
-
-        return new XMLXPath(*this, xpath);
+        *error = *errorXPathBuffer;
+        return 0;
     }
 
-    const XMLObject *XMLDocument::getXMLObjectParent() const
+    xmlXPathObject *xpath = xmlXPathCompiledEval(expr, ctxt);
+
+    xmlSetStructuredErrorFunc(ctxt, 0);
+    xmlXPathFreeContext(ctxt);
+    xmlXPathFreeCompExpr(expr);
+    if (!xpath)
     {
+        *error = *errorXPathBuffer;
         return 0;
     }
 
-    const std::string XMLDocument::toString() const
-    {
-        std::ostringstream oss;
-
-        oss << "XML Document" << std::endl;
-        oss << "URL: " << getDocumentURL();
-
-        return oss.str();
-    }
+    return new XMLXPath(*this, xpath);
+}
 
-    const std::string XMLDocument::dump(bool indent) const
-    {
-        xmlChar *buffer = 0;
-        int size = 0;
-        xmlDocDumpFormatMemory(document, &buffer, &size, indent ? 1 : 0);
-        std::string str = std::string((const char *)buffer);
-        xmlFree(buffer);
+const XMLObject *XMLDocument::getXMLObjectParent() const
+{
+    return 0;
+}
 
-        return str;
-    }
+const std::string XMLDocument::toString() const
+{
+    std::ostringstream oss;
 
-    const XMLElement *XMLDocument::getRoot() const
-    {
-        xmlNode *root = xmlDocGetRootElement(document);
-        if (!root)
-        {
-            return 0;
-        }
+    oss << "XML Document" << std::endl
+        << "url: " << getDocumentURL() << std::endl
+        << "root: " << "XML Element";
 
-        XMLObject *obj = scope->getXMLObjectFromLibXMLPtr(root);
+    return oss.str();
+}
 
-        if (obj)
-        {
-            return static_cast < XMLElement * >(obj);
-        }
+const std::string XMLDocument::dump(bool indent) const
+{
+    xmlChar *buffer = 0;
+    int size = 0;
+    xmlDocDumpFormatMemory(document, &buffer, &size, indent ? 1 : 0);
+    std::string str = std::string((const char *)buffer);
+    xmlFree(buffer);
 
-        return new XMLElement(*this, root);
-    }
+    return str;
+}
 
-    void XMLDocument::setRoot(const XMLElement & elem) const
+const XMLElement *XMLDocument::getRoot() const
+{
+    xmlNode *root = xmlDocGetRootElement(document);
+    if (!root)
     {
-        xmlNode *root = xmlDocGetRootElement(document);
-        if (root != elem.getRealNode())
-        {
-            xmlNode *cpy = xmlCopyNodeList(elem.getRealNode());
-            xmlUnlinkNode(cpy);
-            xmlDocSetRootElement(document, cpy);
-        }
+        return 0;
     }
 
-    void XMLDocument::setRoot(const std::string & xmlCode, std::string * error) const
-    {
-        XMLDocument doc = XMLDocument(xmlCode, false, error);
+    XMLObject *obj = scope->getXMLObjectFromLibXMLPtr(root);
 
-        if (error->empty())
-        {
-            setRoot(*doc.getRoot());
-        }
+    if (obj)
+    {
+        return static_cast < XMLElement * >(obj);
     }
 
-    const char *XMLDocument::getDocumentURL() const
+    return new XMLElement(*this, root);
+}
+
+void XMLDocument::setRoot(const XMLElement & elem) const
+{
+    xmlNode *root = xmlDocGetRootElement(document);
+    if (root != elem.getRealNode())
     {
-        if (document->URL)
-        {
-            return (const char *)document->URL;
-        }
-        else
-        {
-            return "Undefined";
-        }
+        xmlNode *cpy = xmlCopyNodeList(elem.getRealNode());
+        xmlUnlinkNode(cpy);
+        xmlDocSetRootElement(document, cpy);
     }
+}
 
-    void XMLDocument::setDocumentURL(const std::string & url) const
-    {
-        char *expandedPath = 0;
-        char *newURL = 0;
-        expandedPath = expandPathVariable(const_cast < char *>(url.c_str()));
+void XMLDocument::setRoot(const std::string & xmlCode, std::string * error) const
+{
+    XMLDocument doc = XMLDocument(xmlCode, false, error);
 
-        if (expandedPath)
-        {
-            xmlFree((void *)document->URL);
-            newURL = (char *)xmlMalloc(sizeof(char *) * (strlen(expandedPath) + 1));
-            memcpy(newURL, expandedPath, sizeof(char) * (strlen(expandedPath) + 1));
-            document->URL = (xmlChar *) newURL;
-            FREE(expandedPath);
-        }
+    if (error->empty())
+    {
+        setRoot(*doc.getRoot());
     }
+}
 
-    const std::list < XMLDocument * >&XMLDocument::getOpenDocuments()
+const char *XMLDocument::getDocumentURL() const
+{
+    if (document->URL)
     {
-        return openDocs;
+        return (const char *)document->URL;
     }
-
-    void XMLDocument::closeAllDocuments()
+    else
     {
-        int size = (int)openDocs.size();
-        XMLDocument **arr = new XMLDocument *[size];
-        int j = 0;
-
-        for (std::list < XMLDocument * >::iterator i = openDocs.begin(); i != openDocs.end(); i++, j++)
-        {
-            arr[j] = *i;
-        }
-        for (j = 0; j < size; j++)
-        {
-            delete arr[j];
-        }
-        delete[]arr;
+        return "Undefined";
     }
+}
 
-    xmlDoc *XMLDocument::readDocument(const char *filename, bool validate, std::string * error)
+void XMLDocument::setDocumentURL(const std::string & url) const
+{
+    char *expandedPath = 0;
+    char *newURL = 0;
+    expandedPath = expandPathVariable(const_cast < char *>(url.c_str()));
+
+    if (expandedPath)
     {
-        xmlParserCtxt *ctxt = initContext(error, validate);
-        xmlDoc *doc = 0;
-        int options = XML_PARSE_NSCLEAN;
+        xmlFree((void *)document->URL);
+        newURL = (char *)xmlMalloc(sizeof(char *) * (strlen(expandedPath) + 1));
+        memcpy(newURL, expandedPath, sizeof(char) * (strlen(expandedPath) + 1));
+        document->URL = (xmlChar *) newURL;
+        FREE(expandedPath);
+    }
+}
 
-        if (validate)
-        {
-            options = options | XML_PARSE_DTDVALID;
-        }
+const std::list < XMLDocument * >&XMLDocument::getOpenDocuments()
+{
+    return openDocs;
+}
 
-        if (!ctxt)
-        {
-            xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
-            return 0;
-        }
+void XMLDocument::closeAllDocuments()
+{
+    int size = (int)openDocs.size();
+    XMLDocument **arr = new XMLDocument *[size];
+    int j = 0;
 
-        doc = xmlCtxtReadFile(ctxt, filename, 0, options);
-        if (!doc || !ctxt->valid)
-        {
-            *error = *errorBuffer;
-        }
+    for (std::list < XMLDocument * >::iterator i = openDocs.begin(); i != openDocs.end(); i++, j++)
+    {
+        arr[j] = *i;
+    }
+    for (j = 0; j < size; j++)
+    {
+        delete arr[j];
+    }
+    delete[]arr;
+}
 
-        xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
-        xmlFreeParserCtxt(ctxt);
+xmlDoc *XMLDocument::readDocument(const char *filename, bool validate, std::string * error)
+{
+    xmlParserCtxt *ctxt = initContext(error, validate);
+    xmlDoc *doc = 0;
+    int options = XML_PARSE_NSCLEAN;
 
-        return doc;
+    if (validate)
+    {
+        options = options | XML_PARSE_DTDVALID;
     }
 
-    xmlDoc *XMLDocument::readDocument(const std::string & xmlCode, bool validate, std::string * error)
+    if (!ctxt)
     {
-        xmlParserCtxt *ctxt = initContext(error, validate);
-        xmlDoc *doc = 0;
-        int options = XML_PARSE_NSCLEAN;
+        xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
+        return 0;
+    }
 
-        if (validate)
-        {
-            options = options | XML_PARSE_DTDVALID;
-        }
+    doc = xmlCtxtReadFile(ctxt, filename, 0, options);
+    if (!doc || !ctxt->valid)
+    {
+        *error = *errorBuffer;
+    }
 
-        if (!ctxt)
-        {
-            xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
-            return 0;
-        }
+    xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
+    xmlFreeParserCtxt(ctxt);
 
-        doc = xmlCtxtReadDoc(ctxt, (const xmlChar *)xmlCode.c_str(), 0, 0, options);
-        if (!doc || !ctxt->valid)
-        {
-            *error = *errorBuffer;
-        }
+    return doc;
+}
 
-        xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
-        xmlFreeParserCtxt(ctxt);
+xmlDoc *XMLDocument::readDocument(const std::string & xmlCode, bool validate, std::string * error)
+{
+    xmlParserCtxt *ctxt = initContext(error, validate);
+    xmlDoc *doc = 0;
+    int options = XML_PARSE_NSCLEAN;
 
-        return doc;
+    if (validate)
+    {
+        options = options | XML_PARSE_DTDVALID;
     }
 
-    xmlParserCtxt *XMLDocument::initContext(std::string * error, bool validate)
+    if (!ctxt)
     {
-        xmlParserCtxt *ctxt;
+        xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
+        return 0;
+    }
 
-        if (errorBuffer)
-        {
-            delete errorBuffer;
-        }
-        errorBuffer = new std::string();
+    doc = xmlCtxtReadDoc(ctxt, (const xmlChar *)xmlCode.c_str(), 0, 0, options);
+    if (!doc || !ctxt->valid)
+    {
+        *error = *errorBuffer;
+    }
 
-        ctxt = xmlNewParserCtxt();
-        if (!ctxt)
-        {
-            errorBuffer->append(gettext("Cannot create a parser context"));
-            *error = *errorBuffer;
-            return 0;
-        }
+    xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);
+    xmlFreeParserCtxt(ctxt);
 
-        if (validate)
-        {
-            ctxt->vctxt.error = (xmlValidityErrorFunc) errorFunction;
-        }
+    return doc;
+}
 
-        xmlSetGenericErrorFunc(ctxt, errorFunction);
+xmlParserCtxt *XMLDocument::initContext(std::string * error, bool validate)
+{
+    xmlParserCtxt *ctxt;
 
-        return ctxt;
+    if (errorBuffer)
+    {
+        delete errorBuffer;
     }
+    errorBuffer = new std::string();
 
-    void XMLDocument::errorFunction(void *ctx, const char *msg, ...)
+    ctxt = xmlNewParserCtxt();
+    if (!ctxt)
     {
-        char str[BUFFER_SIZE];
-        va_list args;
-
-        va_start(args, msg);
-        vsnprintf(str, BUFFER_SIZE, msg, args);
-        va_end(args);
-        errorBuffer->append(str);
+        errorBuffer->append(gettext("Cannot create a parser context"));
+        *error = *errorBuffer;
+        return 0;
     }
 
-    void XMLDocument::errorXPathFunction(void *ctx, xmlError * error)
+    if (validate)
     {
-        errorXPathBuffer->append(error->message);
+        ctxt->vctxt.error = (xmlValidityErrorFunc) errorFunction;
     }
+
+    xmlSetGenericErrorFunc(ctxt, errorFunction);
+
+    return ctxt;
+}
+
+void XMLDocument::errorFunction(void *ctx, const char *msg, ...)
+{
+    char str[BUFFER_SIZE];
+    va_list args;
+
+    va_start(args, msg);
+    vsnprintf(str, BUFFER_SIZE, msg, args);
+    va_end(args);
+    errorBuffer->append(str);
+}
+
+void XMLDocument::errorXPathFunction(void *ctx, xmlError * error)
+{
+    errorXPathBuffer->append(error->message);
+}
 }
index 2d9fcd7..db8c7b3 100644 (file)
@@ -229,12 +229,17 @@ const std::string XMLElement::toString() const
         }
     }
 
-    oss << "XML Element" << std::endl;
-    oss << "name: " << getNodeName() << std::endl;
-    oss << "namespace href: " << ns << std::endl;
-    oss << "namespace prefix: " << prefix << std::endl;
-    oss << "type: " << nodes_type[getNodeType() - 1] << std::endl;
-    oss << "definition line: " << node->line;
+    oss << "XML Element" << std::endl
+        << "name: " << getNodeName() << std::endl
+        << "namespace: XML Namespace" << std::endl
+        << "    href: " << ns << std::endl
+        << "    prefix: " << prefix << std::endl
+        << "type: " << nodes_type[getNodeType() - 1] << std::endl
+        << "parent: XML Element" << std::endl
+        << "attributes: [1 x " << XMLAttr::getSize(node->properties) << "]" << std::endl
+        << "children: [1 x " << XMLNodeList::getNodeListSize(node->children) << "]" << std::endl
+        << "content: ..." << std::endl
+        << "line: " << node->line;
 
     return oss.str();
 }
index f18473b..75afa24 100644 (file)
@@ -334,11 +334,14 @@ xmlNode *XMLNodeList::getListNode(int index)
     return XMLList::getListElement < xmlNode > (index, size, &prev, &prevNode);
 }
 
-inline int XMLNodeList::getNodeListSize(xmlNode * node)
+int XMLNodeList::getNodeListSize(xmlNode * node)
 {
     int i = 0;
 
-    for (xmlNode * n = node; n; n = n->next, i++) ;
+    for (xmlNode * n = node; n; n = n->next, i++)
+    {
+        ;
+    }
 
     return i;
 }
index ba2bc9e..28c2821 100644 (file)
 
 namespace org_modules_xml
 {
-    class XMLElement;
-    class XMLDocument;
+class XMLElement;
+class XMLDocument;
 
+/**
+ * @file
+ * @author Calixte DENIZET <calixte.denizet@scilab.org>
+ *
+ * Class to wrap the list of the children of a node
+ */
+class XMLNodeList: public XMLList
+{
+
+    const XMLDocument & doc;
+    xmlNode *parent;
+    int prev;
+    xmlNode *prevNode;
+
+public:
     /**
-     * @file
-     * @author Calixte DENIZET <calixte.denizet@scilab.org>
-     *
-     * Class to wrap the list of the children of a node
+     * Default constructor
+     * @param doc the XMLDocument where this nodelist is
+     * @param parent the parent node
      */
-    class XMLNodeList:public XMLList
-    {
+    XMLNodeList(const XMLDocument & doc, xmlNode * parent);
 
-        const XMLDocument & doc;
-        xmlNode *parent;
-        int prev;
-        xmlNode *prevNode;
+    ~XMLNodeList();
 
-public:
-        /**
-         * Default constructor
-         * @param doc the XMLDocument where this nodelist is
-         * @param parent the parent node
-         */
-          XMLNodeList(const XMLDocument & doc, xmlNode * parent);
-
-         ~XMLNodeList();
-
-        void *getRealXMLPointer() const;
-
-        const char **getContentFromList() const;
-
-        const char **getNameFromList() const;
-
-        void remove() const;
-
-        /**
-         * Removes an element
-         * @param index the index of the element to remove
-         */
-        void removeElementAtPosition(int index);
-
-        /**
-         * @anchor setElementAtPosition
-         * Sets an element at a given index.
-         * If the index is an integer, then according to the index value the element
-         * will be inserted at tail, or will replaced the existing one.
-         * If the index is not an integer, then the element will be inserted between the
-         * elements with indexes floor(index) and floor(index)+1.
-         * @param index the index
-         * @param elem the element to insert
-         */
-        void setElementAtPosition(double index, const XMLElement & elem);
-
-        /**
-         * See @ref setElementAtPosition
-         * @param index the index
-         * @param document the document containing the root which will be inserted
-         */
-        void setElementAtPosition(double index, const XMLDocument & document);
-
-        /**
-         * See @ref setElementAtPosition
-         * @param index the index
-         * @param xmlCode the XML code for the element which will be inserted
-         */
-        void setElementAtPosition(double index, const std::string & xmlCode);
-
-        /**
-         * See @ref setElementAtPosition
-         * @param index the index
-         * @param list the list of the elements which will be inserted
-         */
-        void setElementAtPosition(double index, const XMLNodeList & list);
-
-        /**
-         * Gets the parent node behind this children list.
-         * @return the parent node
-         */
-        xmlNode *getRealNode() const
-        {
-            return parent->children;
-        }
-
-        void setAttributeValue(const char **prefix, const char **name, const char **value, int lsize) const;
-        void setAttributeValue(const char **name, const char **value, int lsize) const;
-        const XMLObject *getXMLObjectParent() const;
-        const std::string dump() const;
-        const XMLObject *getListElement(int index);
+    void *getRealXMLPointer() const;
+
+    const char **getContentFromList() const;
+
+    const char **getNameFromList() const;
+
+    void remove() const;
+
+    /**
+     * Removes an element
+     * @param index the index of the element to remove
+     */
+    void removeElementAtPosition(int index);
+
+    /**
+     * @anchor setElementAtPosition
+     * Sets an element at a given index.
+     * If the index is an integer, then according to the index value the element
+     * will be inserted at tail, or will replaced the existing one.
+     * If the index is not an integer, then the element will be inserted between the
+     * elements with indexes floor(index) and floor(index)+1.
+     * @param index the index
+     * @param elem the element to insert
+     */
+    void setElementAtPosition(double index, const XMLElement & elem);
+
+    /**
+     * See @ref setElementAtPosition
+     * @param index the index
+     * @param document the document containing the root which will be inserted
+     */
+    void setElementAtPosition(double index, const XMLDocument & document);
+
+    /**
+     * See @ref setElementAtPosition
+     * @param index the index
+     * @param xmlCode the XML code for the element which will be inserted
+     */
+    void setElementAtPosition(double index, const std::string & xmlCode);
 
+    /**
+     * See @ref setElementAtPosition
+     * @param index the index
+     * @param list the list of the elements which will be inserted
+     */
+    void setElementAtPosition(double index, const XMLNodeList & list);
+
+    /**
+     * Gets the parent node behind this children list.
+     * @return the parent node
+     */
+    xmlNode *getRealNode() const
+    {
+        return parent->children;
+    }
+
+    void setAttributeValue(const char **prefix, const char **name, const char **value, int lsize) const;
+    void setAttributeValue(const char **name, const char **value, int lsize) const;
+    const XMLObject *getXMLObjectParent() const;
+    const std::string dump() const;
+    const XMLObject *getListElement(int index);
+
+    /**
+     * Gets the node list size
+     * @param node the xmlNode
+     * @return the size
+     */
+    static int getNodeListSize(xmlNode * node);
 protected:
-        /**
-         * Replaces an element at a given index
-         * @param index the index
-         * @param elem the new element
-         */
-        void replaceAtIndex(int index, const XMLElement & elem);
-
-        /**
-         * Inserts an element at beginning
-         * @param elem the element to insert
-         */
-        void insertAtEnd(const XMLElement & elem);
-
-        /**
-         * Inserts an element at end
-         * @param elem the element to insert
-         */
-        void insertAtBeginning(const XMLElement & elem);
-
-        /**
-         * Inserts an element at a given index
-         * @param index the index
-         * @param elem the element to insert
-         */
-        void insertAtIndex(int index, const XMLElement & elem);
+    /**
+     * Replaces an element at a given index
+     * @param index the index
+     * @param elem the new element
+     */
+    void replaceAtIndex(int index, const XMLElement & elem);
+
+    /**
+     * Inserts an element at beginning
+     * @param elem the element to insert
+     */
+    void insertAtEnd(const XMLElement & elem);
+
+    /**
+     * Inserts an element at end
+     * @param elem the element to insert
+     */
+    void insertAtBeginning(const XMLElement & elem);
+
+    /**
+     * Inserts an element at a given index
+     * @param index the index
+     * @param elem the element to insert
+     */
+    void insertAtIndex(int index, const XMLElement & elem);
 
 private:
-        /**
-         * Gets the node list size
-         * @param node the xmlNode
-         * @return the size
-         */
-        static int getNodeListSize(xmlNode * node);
-
-        /**
-         * Gets a node at a given index
-         * @param index the index
-         * @return the correspionding node
-         */
-        xmlNode *getListNode(int index);
-
-    };
+    /**
+     * Gets a node at a given index
+     * @param index the index
+     * @return the correspionding node
+     */
+    xmlNode *getListNode(int index);
+
+};
 }
 
 #endif
index a85a94f..61567c3 100644 (file)
@@ -8,7 +8,8 @@ doc = xmlReadStr("<root><foo a=""123"" b=""456"" c=""789""/></root>")
  doc  =
  
 XML Document
-URL: Undefined
+url: Undefined
+root: XML Element
 assert_checkequal(xmlName(doc.root.children(1)),"foo");
 assert_checkequal(xmlName(doc.root.children(1).attributes),["a" "b" "c"]);
 assert_checkequal(xmlName(xmlXPath(doc,"//foo/@*")),["a" "b" "c"]);