Changeset 17362 in vbox for trunk/src/VBox/Main/xml

Timestamp:

Mar 4, 2009 6:10:58 PM (16 years ago)

Author:

vboxsync

Message:

OVF: partial implementation of write support in XML classes.

File:

• trunk/src/VBox/Main/xml/xml.cpp (modified) (19 diffs)

trunk/src/VBox/Main/xml/xml.cpp

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2007-2008 Sun Microsystems, Inc.
+ * Copyright (C) 2007-2009 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -42 +42 @@
 #include "VBox/xml.h"
 
+////////////////////////////////////////////////////////////////////////////////
+//
+// globals
+//
+////////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -94 +99 @@
 {
 
-//////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//
 // Exceptions
-//////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////
 
 LogicError::LogicError(RT_SRC_POS_DECL)
@@ -111 +118 @@
 {
     if (!aErr)
-        throw EInvalidArg (RT_SRC_POS);
+        throw EInvalidArg(RT_SRC_POS);
 
     char *msg = Format(aErr);
@@ -148 +155 @@
 }
 
-//////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//
 // File Class
+//
 //////////////////////////////////////////////////////////////////////////////
 
@@ -283 +292 @@
 }
 
-//////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//
 // MemoryBuf Class
+//
 //////////////////////////////////////////////////////////////////////////////
 
@@ -349 +360 @@
 }
 
-/*
- * GlobalLock
- *
- *
- */
+////////////////////////////////////////////////////////////////////////////////
+//
+// GlobalLock class
+//
+////////////////////////////////////////////////////////////////////////////////
 
 struct GlobalLock::Data
@@ -392 +403 @@
 }
 
-/*
- * Node
- *
- *
- */
+////////////////////////////////////////////////////////////////////////////////
+//
+// Node class
+//
+////////////////////////////////////////////////////////////////////////////////
 
 struct Node::Data
 {
     xmlNode     *plibNode;          // != NULL if this is an element
-    xmlAttr     *plibAttr;          // != NULL if this is an element
-
-    Node     *pParent;       // NULL only for the root element
+    xmlAttr     *plibAttr;          // != NULL if this is an attribute
+
+    Node        *pParent;           // NULL only for the root element
     const char  *pcszName;          // points either into plibNode or plibAttr
 
@@ -790 +801 @@
 }
 
-/*
- * Document
- *
- *
- */
+////////////////////////////////////////////////////////////////////////////////
+//
+// Document class
+//
+////////////////////////////////////////////////////////////////////////////////
 
 struct Document::Data
 {
-    xmlDocPtr   pDocument;
-    Node     *pRootElement;
+    xmlDocPtr   plibDocument;
+    Node        *pRootElement;
 
     Data()
     {
-        pDocument = NULL;
+        plibDocument = NULL;
         pRootElement = NULL;
     }
@@ -814 +825 @@
     void reset()
     {
-        if (pDocument)
+        if (plibDocument)
         {
-            xmlFreeDoc(pDocument);
-            pDocument = NULL;
+            xmlFreeDoc(plibDocument);
+            plibDocument = NULL;
         }
         if (pRootElement)
@@ -828 +839 @@
     void copyFrom(const Document::Data *p)
     {
-        if (p->pDocument)
+        if (p->plibDocument)
         {
-            pDocument = xmlCopyDoc(p->pDocument,
-                                   1);      // recursive == copy all
+            plibDocument = xmlCopyDoc(p->plibDocument,
+                                      1);      // recursive == copy all
         }
     }
@@ -867 +878 @@
 {
     m->pRootElement = new Node();
-    m->pRootElement->m->plibNode = xmlDocGetRootElement(m->pDocument);
+    m->pRootElement->m->plibNode = xmlDocGetRootElement(m->plibDocument);
     m->pRootElement->m->pcszName = (const char*)m->pRootElement->m->plibNode->name;
 
@@ -873 +884 @@
 }
 
+/**
+ * Returns the root element of the document, or NULL if the document is empty.
+ * @return
+ */
 const Node* Document::getRootElement() const
 {
@@ -878 +893 @@
 }
 
-/*
- * XmlParserBase
- *
- *
- */
+/**
+ * Creates a new element node and sets it as the root element. This will
+ * only work if the document is empty; otherwise EDocumentNotEmpty is thrown.
+ */
+Node* Document::createRootElement(const char *pcszRootElementName)
+{
+    if (m->pRootElement)
+        throw EDocumentNotEmpty(RT_SRC_POS);
+
+    m->plibDocument = xmlNewDoc((const xmlChar*)"1.0");
+    if (!(m->pRootElement = new Node()))
+        throw ENoMemory();
+    Node::Data *pNodeData = m->pRootElement->m;
+    if (!(pNodeData->plibNode = xmlNewNode(NULL,        // namespace
+                                           (const xmlChar*)pcszRootElementName)))
+        throw ENoMemory();
+    pNodeData->pcszName = (const char*)pNodeData->plibNode->name;
+
+    return m->pRootElement;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// XmlParserBase class
+//
+////////////////////////////////////////////////////////////////////////////////
 
 XmlParserBase::XmlParserBase()
@@ -897 +933 @@
 }
 
-/*
- * XmlFileParser
- *
- *
- */
+////////////////////////////////////////////////////////////////////////////////
+//
+// XmlFileParser class
+//
+////////////////////////////////////////////////////////////////////////////////
 
 struct XmlFileParser::Data
@@ -931 +967 @@
 }
 
-struct ReadContext
+struct ReadWriteContext
 {
     File file;
     com::Utf8Str error;
 
-    ReadContext(const char *pcszFilename)
-        : file(File::Mode_Read, pcszFilename)
+    ReadWriteContext(const char *pcszFilename)
+        : file(File::Mode_Read, pcszFilename)     // @todo must be write for writer
     {
     }
@@ -969 +1005 @@
     m->strXmlFilename = pcszFilename;
 
-    ReadContext context(pcszFilename);
+    ReadWriteContext context(pcszFilename);
     doc.m->reset();
-    if (!(doc.m->pDocument = xmlCtxtReadIO(m->ctxt,
-                                           ReadCallback,
-                                           CloseCallback,
-                                           &context,
-                                           pcszFilename,
-                                           NULL,       // encoding = auto
-                                           XML_PARSE_NOBLANKS)))
+    if (!(doc.m->plibDocument = xmlCtxtReadIO(m->ctxt,
+                                              ReadCallback,
+                                              CloseCallback,
+                                              &context,
+                                              pcszFilename,
+                                              NULL,       // encoding = auto
+                                              XML_PARSE_NOBLANKS)))
         throw XmlError(xmlCtxtGetLastError(m->ctxt));
 
@@ -986 +1022 @@
 int XmlFileParser::ReadCallback(void *aCtxt, char *aBuf, int aLen)
 {
-    ReadContext *pContext = static_cast<ReadContext*>(aCtxt);
+    ReadWriteContext *pContext = static_cast<ReadWriteContext*>(aCtxt);
 
     /* To prevent throwing exceptions while inside libxml2 code, we catch
@@ -1010 +1046 @@
 }
 
+////////////////////////////////////////////////////////////////////////////////
+//
+// XmlFileWriter class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct XmlFileWriter::Data
+{
+    Document *pDoc;
+};
+
+XmlFileWriter::XmlFileWriter(Document &doc)
+{
+    m = new Data();
+    m->pDoc = &doc;
+}
+
+XmlFileWriter::~XmlFileWriter()
+{
+    delete m;
+}
+
+int XmlFileWriter::WriteCallback(void *aCtxt, const char *aBuf, int aLen)
+{
+    ReadWriteContext *pContext = static_cast<ReadWriteContext*>(aCtxt);
+
+    /* To prevent throwing exceptions while inside libxml2 code, we catch
+     * them and forward to our level using a couple of variables. */
+    try
+    {
+        return pContext->file.write(aBuf, aLen);
+    }
+    catch (const xml::EIPRTFailure &err) { pContext->setError(err); }
+    catch (const xml::Error &err) { pContext->setError(err); }
+    catch (const std::exception &err) { pContext->setError(err); }
+    catch (...) { pContext->setError(xml::LogicError(RT_SRC_POS)); }
+
+    return -1 /* failure */;
+}
+
+int XmlFileWriter::CloseCallback(void *aCtxt)
+{
+    /// @todo to be written
+
+    return -1;
+}
+
+void XmlFileWriter::write(const char *pcszFilename)
+{
+    ReadWriteContext context(pcszFilename);
+
+    GlobalLock lock();
+
+    /* serialize to the stream */
+    xmlIndentTreeOutput = 1;
+    xmlTreeIndentString = "  ";
+    xmlSaveNoEmptyTags = 0;
+
+    xmlSaveCtxtPtr saveCtxt;
+    if (!(saveCtxt = xmlSaveToIO(WriteCallback,
+                                 CloseCallback,
+                                 &context,
+                                 NULL,
+                                 XML_SAVE_FORMAT)))
+        throw xml::LogicError(RT_SRC_POS);
+
+    long rc = xmlSaveDoc(saveCtxt, m->pDoc->m->plibDocument);
+    if (rc == -1)
+    {
+        /* look if there was a forwared exception from the lower level */
+//         if (m->trappedErr.get() != NULL)
+//             m->trappedErr->rethrow();
+
+        /* there must be an exception from the Output implementation,
+         * otherwise the save operation must always succeed. */
+        throw xml::LogicError(RT_SRC_POS);
+    }
+
+    xmlSaveClose(saveCtxt);
+}
+
 
 } // end namespace xml