/**
      This file is part of GoldenGate Project (named also GoldenGate or GG).
   
      Copyright 2009, Frederic Bregier, and individual contributors by the @author
      tags. See the COPYRIGHT.txt in the distribution for a full listing of
      individual contributors.
   
      All GoldenGate Project 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 3 of the License, or
     (at your option) any later version.
  
     GoldenGate 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 GoldenGate .  If not, see <http://www.gnu.org/licenses/>.
   */
  package goldengate.common.xml;
  
  import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InvalidObjectException;
  import java.util.List;
  
  import org.dom4j.Document;
  import org.dom4j.DocumentException;
  import org.dom4j.DocumentHelper;
  import org.dom4j.Element;
  import org.dom4j.io.OutputFormat;
  import org.dom4j.io.SAXReader;
  import org.dom4j.io.XMLWriter;
  
  /**
   * XML utility that handles simple cases as:<br>
   * <ul>
   * <li>XPath as /x/y/z for a node and referring to root of Document</li>
   * <li>XPath as x/y/z for a node and referring to current referenced node</li>
   * <li>Any XPath can be a singleton (unique node referenced by the XPath) or
   * multiple nodes (same XPath)</li>
   * <li>Only Element as Node: no Attribute or any other type within XML</li>
   * <li>Any other path is not supported: //x /x@y ./ ../</li>
   * <li>Supports special SubXml tree as element (singleton or multiple)</li>
   * </ul>
   * 
   * @author Frederic Bregier
   * 
   */
  public class XmlUtil {
  
      /**
       * 
       * @param filename
       * @return Existing Document from filename
       * @throws IOException
       * @throws DocumentException
       */
      static public Document getDocument(String filename) throws IOException,
              DocumentException {
          File file = new File(filename);
          if (!file.canRead()) {
              throw new IOException("File is not readable: " + filename);
          }
          return getDocument(file);
      }
  
      /**
       * 
       * @param file
       * @return Existing Document from file
       * @throws IOException
       * @throws DocumentException
       */
      static public Document getDocument(File file) throws IOException,
              DocumentException {
          if (!file.canRead()) {
              throw new IOException("File is not readable: " + file.getPath());
          }
          SAXReader reader = new SAXReader();
          return reader.read(file);
      }
  
      /**
       * Read the document from the string
       * 
       * @param document
       *            as String
       * @return the Document
       * @throws DocumentException
       */
      static public Document readDocument(String document)
              throws DocumentException {
          return DocumentHelper.parseText(document);
      }
  
      /**
      * 
      * @param document
      * @return the document as an XML string
      */
     static public String writeToString(Document document) {
         return document.asXML();
     }
 
     /**
      * 
      * @param element
      * @return the element as an XML string
      */
     static public String writeToString(Element element) {
         return element.asXML();
     }
 
     /**
      * 
      * @return an empty new Document
      */
     static public Document createEmptyDocument() {
         return DocumentHelper.createDocument();
     }
 
     /**
      * Save the document into the file
      * 
      * @param filename
      * @param document
      * @throws IOException
      */
     static public void saveDocument(String filename, Document document)
             throws IOException {
         File file = new File(filename);
         saveDocument(file, document);
     }
 
     /**
      * Save the document into the file
      * 
      * @param file
      * @param document
      * @throws IOException
      */
     static public void saveDocument(File file, Document document)
             throws IOException {
         if (file.exists() && (!file.canWrite())) {
             throw new IOException("File is not writable: " + file.getPath());
         }
         OutputFormat format = OutputFormat.createPrettyPrint();
         XMLWriter writer = new XMLWriter(new FileWriter(file), format);
         writer.write(document);
         writer.flush();
         writer.close();
     }
 
     /**
      * Save the branch from element into the file
      * 
      * @param filename
      * @param element
      * @throws IOException
      */
     static public void saveElement(String filename, Element element)
             throws IOException {
         File file = new File(filename);
         saveElement(file, element);
     }
 
     /**
      * Save the branch from element into the file
      * 
      * @param file
      * @param element
      * @throws IOException
      */
     static public void saveElement(File file, Element element)
             throws IOException {
         if (file.exists() && (!file.canWrite())) {
             throw new IOException("File is not writable: " + file.getPath());
         }
         OutputFormat format = OutputFormat.createPrettyPrint();
         XMLWriter writer = new XMLWriter(new FileWriter(file), format);
         writer.write(element);
         writer.flush();
         writer.close();
     }
 
     /**
      * 
      * @param document
      * @return the root Element from the document
      */
     static public Element getRootElement(Document document) {
         return document.getRootElement();
     }
 
     /**
      * Add or Get (if already existing) an element given by the path relative to
      * the referent element and set the value
      * 
      * @param ref
      * @param path
      * @param value
      * @return the new added or already existing element with new value
      */
     static public Element addOrSetElement(Element ref, String path, String value) {
         Element current = addOrGetElement(ref, path);
         current.setText(value);
         return current;
     }
 
     /**
      * Add or Get (if already existing) an element given by the path relative to
      * the referent element
      * 
      * @param ref
      * @param path
      * @return the new added or already existing element
      */
     static public Element addOrGetElement(Element ref, String path) {
         String[] pathes = path.split("/");
         Element current = ref;
         for (String nodename: pathes) {
             if (nodename.length() > 0) {
                 Element exist = current.element(nodename);
                 if (exist == null) {
                     current = current.addElement(nodename);
                 } else {
                     current = exist;
                 }
             }
         }
         return current;
     }
 
     /**
      * Add an element given by the path relative to the referent element and set the value
      * 
      * @param ref
      * @param path
      * @param value
      * @return the new added element with value
      */
     static public Element addAndSetElementMultiple(Element ref, String path,
             String value) {
         Element current = addAndGetElementMultiple(ref, path);
         current.setText(value);
         return current;
     }
 
     /**
      * Add an element given by the path relative to the referent element
      * 
      * @param ref
      * @param path
      * @return the new added element
      */
     static public Element addAndGetElementMultiple(Element ref, String path) {
         String[] pathes = path.split("/");
         Element current = ref;
         for (int i = 0; i < pathes.length - 1; i ++) {
             String nodename = pathes[i];
             if (nodename.length() > 0) {
                 Element exist = current.element(nodename);
                 if (exist == null) {
                     current = current.addElement(nodename);
                 } else {
                     current = exist;
                 }
             }
         }
         String nodename = pathes[pathes.length - 1];
         if (nodename.length() > 0) {
             current = current.addElement(nodename);
         }
         return current;
     }
 
     /**
      * 
      * @param ref
      * @param path
      * @return the parent element associated with the path relatively to the
      *         referent element
      * @throws DocumentException
      */
     static public Element getParentElement(Element ref, String path)
             throws DocumentException {
         String npath = path;
         while (npath.charAt(0) == '/') {//startsWith("/")) {
             npath = npath.substring(1);
         }
         Element current = (Element) ref.selectSingleNode(npath);
         if (current == null) {
             throw new DocumentException("Node not found: " + path);
         }
         return current.getParent();
     }
 
     /**
      * 
      * @param ref
      * @param path
      * @return the element associated with the path relatively to the referent
      *         element
      * @throws DocumentException
      */
     static public Element getElement(Element ref, String path)
             throws DocumentException {
         String npath = path;
         while (npath.charAt(0) == '/') {//.startsWith("/")) {
             npath = npath.substring(1);
         }
         Element current = (Element) ref.selectSingleNode(npath);
         if (current == null) {
             throw new DocumentException("Node not found: " + path);
         }
         return current;
     }
 
     /**
      * 
      * @param ref
      * @param path
      * @return the element associated with the path relatively to the referent
      *         element
      * @throws DocumentException
      */
     @SuppressWarnings("unchecked")
     static public List<Element> getElementMultiple(Element ref, String path)
             throws DocumentException {
         String npath = path;
         while (npath.charAt(0) == '/') {//.startsWith("/")) {
             npath = npath.substring(1);
         }
         List<Element> list = ref.selectNodes(npath);
         if (list == null || list.isEmpty()) {
             throw new DocumentException("Nodes not found: " + path);
         }
         return list;
     }
 
     /**
      * Add or Get (if already existing) an element given by the path relative to
      * the document and set the value
      * 
      * @param doc
      * @param path
      * @param value
      * @return the new added or already existing element with new value
      */
     static public Element addOrSetElement(Document doc, String path,
             String value) {
         Element current = addOrGetElement(doc, path);
         current.setText(value);
         return current;
     }
 
     /**
      * Add or Get (if already existing) an element given by the path relative to
      * the document
      * 
      * @param doc
      * @param path
      * @return the new added or already existing element
      */
     static public Element addOrGetElement(Document doc, String path) {
         String[] pathes = path.split("/");
         int rank = 0;
         for (rank = 0; rank < pathes.length; rank ++) {
             if (pathes[rank].length() > 0) {
                 break; // found
             }
         }
         if (rank >= pathes.length) {
             return null; // Should not be !
         }
         Element current = (Element) doc.selectSingleNode(pathes[rank]);
         if (current == null) {
             current = doc.addElement(pathes[rank]);
         }
         for (int i = rank + 1; i < pathes.length; i ++) {
             String nodename = pathes[i];
             if (nodename.length() > 0) {
                 Element exist = current.element(nodename);
                 if (exist == null) {
                     current = current.addElement(nodename);
                 } else {
                     current = exist;
                 }
             }
         }
         return current;
     }
 
     /**
      * Add an element given by the path relative to the document and set the value
      * 
      * @param doc
      * @param path
      * @param value
      * @return the new added element with value
      */
     static public Element addAndSetElementMultiple(Document doc, String path,
             String value) {
         Element current = addAndGetElementMultiple(doc, path);
         current.setText(value);
         return current;
     }
 
     /**
      * Add an element given by the path relative to the document
      * 
      * @param doc
      * @param path
      * @return the new added element
      */
     static public Element addAndGetElementMultiple(Document doc, String path) {
         String[] pathes = path.split("/");
         int rank = 0;
         for (rank = 0; rank < pathes.length; rank ++) {
             if (pathes[rank].length() > 0) {
                 break; // found
             }
         }
         if (rank >= pathes.length) {
             return null; // Should not be !
         }
         Element current = (Element) doc.selectSingleNode(pathes[rank]);
         if (current == null) {
             current = doc.addElement(pathes[rank]);
         }
         if (rank == pathes.length - 1) {
             // Last level is the root !!! No multiple root is allowed !!!
             // So just give back the root if it exists
             return current;
         }
         for (int i = rank + 1; i < pathes.length - 1; i ++) {
             String nodename = pathes[i];
             if (nodename.length() > 0) {
                 Element exist = current.element(nodename);
                 if (exist == null) {
                     current = current.addElement(nodename);
                 } else {
                     current = exist;
                 }
             }
         }
         String nodename = pathes[pathes.length - 1];
         if (nodename.length() > 0) {
             current = current.addElement(nodename);
         }
         return current;
     }
 
     /**
      * 
      * @param doc
      * @param path
      * @return the Parent element associated with the path relatively to the
      *         document
      * @throws DocumentException
      */
     static public Element getParentElement(Document doc, String path)
             throws DocumentException {
         Element current = (Element) doc.selectSingleNode(path);
         if (current == null) {
             throw new DocumentException("Node not found: " + path);
         }
         return current.getParent();
     }
 
     /**
      * 
      * @param doc
      * @param path
      * @return the element associated with the path relatively to the document
      * @throws DocumentException
      */
     static public Element getElement(Document doc, String path)
             throws DocumentException {
         Element current = (Element) doc.selectSingleNode(path);
         if (current == null) {
             throw new DocumentException("Node not found: " + path);
         }
         return current;
     }
 
     /**
      * 
      * @param doc
      * @param path
      * @return the element associated with the path relatively to the document
      * @throws DocumentException
      */
     @SuppressWarnings("unchecked")
     static public List<Element> getElementMultiple(Document doc, String path)
             throws DocumentException {
         List<Element> list = doc.selectNodes(path);
         if (list == null || list.isEmpty()) {
             throw new DocumentException("Nodes not found: " + path);
         }
         return list;
     }
 
     /**
      * Create the XmlValues from the XmlDevls and the Document
      * 
      * @param doc
      * @param decls
      * @return XmlValues
      */
     static public XmlValue[] read(Document doc, XmlDecl[] decls) {
         XmlValue[] values = null;
         int len = decls.length;
         values = new XmlValue[len];
         for (int i = 0; i < len; i ++) {
             XmlValue value = new XmlValue(decls[i]);
             values[i] = value;
             if (decls[i].isSubXml()) {
                 if (decls[i].isMultiple()) {
                     List<Element> elts;
                     try {
                         elts = getElementMultiple(doc, decls[i].getXmlPath());
                     } catch (DocumentException e) {
                         continue;
                     }
                     for (Element element: elts) {
                         XmlValue[] newValue = read(element,
                                 decls[i].getSubXml());
                         if (newValue == null) {
                             continue;
                         }
                         try {
                             value.addValue(newValue);
                         } catch (InvalidObjectException e) {
                             continue;
                         }
                     }
                 } else {
                     Element element;
                     try {
                         element = getElement(doc, decls[i].getXmlPath());
                     } catch (DocumentException e) {
                         continue;
                     }
                     XmlValue[] newValue = read(element, decls[i].getSubXml());
                     if (newValue == null) {
                         continue;
                     }
                     try {
                         value.setValue(newValue);
                     } catch (InvalidObjectException e) {
                         continue;
                     }
                 }
             } else if (decls[i].isMultiple()) {
                 List<Element> elts;
                 try {
                     elts = getElementMultiple(doc, decls[i].getXmlPath());
                 } catch (DocumentException e) {
                     continue;
                 }
                 for (Element element: elts) {
                     String svalue = element.getText();
                     try {
                         value.addFromString(svalue);
                     } catch (InvalidObjectException e) {
                         continue;
                     }
                 }
             } else {
                 Element element;
                 try {
                     element = getElement(doc, decls[i].getXmlPath());
                 } catch (DocumentException e) {
                     continue;
                 }
                 String svalue = element.getText();
                 value.setFromString(svalue);
             }
         }
         return values;
     }
 
     /**
      * Create the XmlValues from the XmlDevls and the reference Element
      * 
      * @param ref
      * @param decls
      * @return XmlValues
      */
     static public XmlValue[] read(Element ref, XmlDecl[] decls) {
         XmlValue[] values = null;
         int len = decls.length;
         values = new XmlValue[len];
         for (int i = 0; i < len; i ++) {
             XmlValue value = new XmlValue(decls[i]);
             values[i] = value;
             if (decls[i].isSubXml()) {
                 if (decls[i].isMultiple()) {
                     List<Element> elts;
                     try {
                         elts = getElementMultiple(ref, decls[i].getXmlPath());
                     } catch (DocumentException e) {
                         continue;
                     }
                     for (Element element: elts) {
                         XmlValue[] newValue = read(element,
                                 decls[i].getSubXml());
                         if (newValue == null) {
                             continue;
                         }
                         try {
                             value.addValue(newValue);
                         } catch (InvalidObjectException e) {
                             continue;
                         }
                     }
                 } else {
                     Element element;
                     try {
                         element = getElement(ref, decls[i].getXmlPath());
                     } catch (DocumentException e) {
                         continue;
                     }
                     XmlValue[] newValue = read(element, decls[i].getSubXml());
                     if (newValue == null) {
                         continue;
                     }
                     try {
                         value.setValue(newValue);
                     } catch (InvalidObjectException e) {
                         continue;
                     }
                 }
             } else if (decls[i].isMultiple()) {
                 List<Element> elts;
                 try {
                     elts = getElementMultiple(ref, decls[i].getXmlPath());
                 } catch (DocumentException e) {
                     continue;
                 }
                 for (Element element: elts) {
                     String svalue = element.getText();
                     try {
                         value.addFromString(svalue);
                     } catch (InvalidObjectException e) {
                         continue;
                     }
                 }
             } else {
                 Element element;
                 try {
                     element = getElement(ref, decls[i].getXmlPath());
                 } catch (DocumentException e) {
                     continue;
                 }
                 String svalue = element.getText();
                 value.setFromString(svalue);
             }
         }
         return values;
     }
 
     /**
      * Add all nodes from XmlValues into Document
      * 
      * @param doc
      * @param values
      */
     @SuppressWarnings("unchecked")
     public static void write(Document doc, XmlValue[] values) {
         int len = values.length;
         for (int i = 0; i < len; i ++) {
             if (values[i] != null) {
                 if (values[i].isSubXml()) {
                     if (values[i].isMultiple()) {
                         List<XmlValue[]> list = (List<XmlValue[]>) values[i]
                                 .getList();
                         for (XmlValue[] object: list) {
                             Element ref = addAndGetElementMultiple(doc,
                                     values[i].getXmlPath());
                             write(ref, object);
                         }
                     } else {
                         Element ref = addOrGetElement(doc,
                                 values[i].getXmlPath());
                         write(ref, values[i].getSubXml());
                     }
                 } else if (values[i].isMultiple()) {
                     List<?> list = values[i].getList();
                     for (Object object: list) {
                         addAndSetElementMultiple(doc, values[i].getXmlPath(),
                                 object.toString());
                     }
                 } else {
                     addOrSetElement(doc, values[i].getXmlPath(),
                             values[i].getIntoString());
                 }
             }
         }
     }
 
     /**
      * Add all nodes from XmlValues from the referenced Element
      * 
      * @param ref
      * @param values
      */
     @SuppressWarnings("unchecked")
     public static void write(Element ref, XmlValue[] values) {
         int len = values.length;
         for (int i = 0; i < len; i ++) {
             if (values[i] != null) {
                 if (values[i].isSubXml()) {
                     if (values[i].isMultiple()) {
                         List<XmlValue[]> list = (List<XmlValue[]>) values[i]
                                 .getList();
                         for (XmlValue[] object: list) {
                             Element newref = addAndGetElementMultiple(ref,
                                     values[i].getXmlPath());
                             write(newref, object);
                         }
                     } else {
                         Element newref = addOrGetElement(ref,
                                 values[i].getXmlPath());
                         write(newref, values[i].getSubXml());
                     }
                 } else if (values[i].isMultiple()) {
                     List<?> list = values[i].getList();
                     for (Object object: list) {
                         addAndSetElementMultiple(ref, values[i].getXmlPath(),
                                 object.toString());
                     }
                 } else {
                     addOrSetElement(ref, values[i].getXmlPath(),
                             values[i].getIntoString());
                 }
             }
         }
     }
 
     /**
      * Example (run test)
      * @param args
      */
     @SuppressWarnings("unchecked")
     public static void main(String[] args) {
         XmlDecl[] decls = {
                 new XmlDecl("n1", XmlType.BOOLEAN, "/root/bool", false),
                 new XmlDecl("n2", XmlType.FLOAT, "/root/float", false),
                 new XmlDecl("n3", XmlType.STRING, "/root/string", false),
                 new XmlDecl("n4", XmlType.INTEGER, "/root/int", false),
                 new XmlDecl("n5", XmlType.BOOLEAN, "/root/sub1/sub2/bool",
                         false),
                 new XmlDecl("n6", XmlType.BOOLEAN, "/root/sub1/sub3/bool", true),
                 new XmlDecl("n7", XmlType.BOOLEAN,
                         "/root/sub4/sub5/sub6/sub7/bool", false) };
         String xmltree = "<root><bool>true</bool><float>1.2</float><string>my string to read</string><int>5</int>"
                 + "<sub1>"
                 + "<sub2><bool>1</bool></sub2>"
                 + "<sub3>"
                 + "<bool>false</bool><bool>true</bool><bool>0</bool>"
                 + "</sub3>"
                 + "</sub1>"
                 + "<sub4><sub5><sub6><sub7><bool>True</bool></sub7></sub6></sub5></sub4>"
                 + "</root>";
         // Test with only single XmlType (no XVAL)
         Document document = null;
         try {
             document = readDocument(xmltree);
         } catch (DocumentException e) {
             e.printStackTrace();
             return;
         }
         try {
             saveDocument("D:\\Tools\\test-src.xml", document);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         XmlValue[] values = read(document, decls);
         Document newDoc = createEmptyDocument();
         write(newDoc, values);
         String text = writeToString(newDoc);
         System.err.println(text);
         try {
             saveDocument("D:\\Tools\\test.xml", newDoc);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         try {
             newDoc = getDocument("D:\\Tools\\test.xml");
         } catch (IOException e) {
             e.printStackTrace();
             return;
         } catch (DocumentException e) {
             e.printStackTrace();
             return;
         }
         values = read(newDoc, decls);
         XmlHash hash = new XmlHash(values);
         XmlValue value = hash.get("n6");
         if (value != null) {
             if (value.isMultiple()) {
                 try {
                     value.addFromString("true");
                 } catch (InvalidObjectException e) {
                     e.printStackTrace();
                 }
             }
         }
         value = hash.get("n3");
         if (value != null) {
             if (!value.isMultiple()) {
                 try {
                     value.setValue("New String as replacement");
                 } catch (InvalidObjectException e) {
                     e.printStackTrace();
                 }
             }
         }
         newDoc = createEmptyDocument();
         write(newDoc, values);
         try {
             saveDocument("D:\\Tools\\test2.xml", newDoc);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         Element elt = null;
         try {
             elt = getElement(newDoc, "/root/sub4");
         } catch (DocumentException e1) {
             e1.printStackTrace();
             return;
         }
         XmlValue[] oldValues = read(document, decls);
         write(elt, oldValues);
         try {
             saveDocument("D:\\Tools\\test3.xml", newDoc);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         write(newDoc, oldValues);
         try {
             saveDocument("D:\\Tools\\test4.xml", newDoc);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         try {
             saveElement("D:\\Tools\\test5.xml",
                     (Element) elt.selectSingleNode("root"));
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         // Now test XmlType.XVAL
         System.err.println("\n\nXVAL TESTING\n");
         XmlDecl[] subdecls1 = {
                 new XmlDecl("n11", XmlType.BOOLEAN, "/n11/bool", false),
                 new XmlDecl("n12", XmlType.FLOAT, "/n11/float", true) };
         XmlDecl[] subdecls2 = {
                 new XmlDecl("n21", XmlType.BOOLEAN, "/n21/bool", false),
                 new XmlDecl("n22", XmlType.FLOAT, "/n21/float", true) };
         XmlDecl[] maindecls = {
                 new XmlDecl("n1", XmlType.BOOLEAN, "/root/bool", false),
                 new XmlDecl("n2", XmlType.FLOAT, "/root/float", false),
                 new XmlDecl("n3", XmlType.STRING, "/root/string", false),
                 new XmlDecl("n4", XmlType.INTEGER, "/root/int", false),
                 new XmlDecl("n5", XmlType.BOOLEAN, "/root/sub1/sub2/bool",
                         false),
                 new XmlDecl("n6", XmlType.BOOLEAN, "/root/sub1/sub3/bool", true),
                 new XmlDecl("n7", XmlType.BOOLEAN,
                         "/root/sub4/sub5/sub6/sub7/bool", false),
                 new XmlDecl("n10", XmlType.XVAL, "/root/sub8", subdecls1, false),
                 new XmlDecl("n20", XmlType.XVAL, "/root/sub9", subdecls2, true) };
         xmltree = "<root><bool>true</bool><float>1.2</float><string>my string to read</string><int>5</int>"
                 + "<sub1>"
                 + "<sub2><bool>1</bool></sub2>"
                 + "<sub3>"
                 + "<bool>false</bool><bool>true</bool><bool>0</bool>"
                 + "</sub3>"
                 + "</sub1>"
                 + "<sub4><sub5><sub6><sub7><bool>True</bool></sub7></sub6></sub5></sub4>"
                 + "<sub8><n11><bool>true</bool><float>1.2</float><float>1.3</float><float>1.4</float></n11></sub8>"
                 + "<sub9><n21><bool>true</bool><float>2.2</float><float>2.3</float><float>2.4</float></n21></sub9>"
                 + "<sub9><n21><bool>false</bool><float>3.2</float><float>3.3</float><float>3.4</float></n21></sub9>"
                 + "<sub9><n21><bool>true</bool><float>4.2</float><float>4.3</float><float>4.4</float></n21></sub9>"
                 + "</root>";
         document = null;
         try {
             document = readDocument(xmltree);
         } catch (DocumentException e) {
             e.printStackTrace();
             return;
         }
         try {
             saveDocument("D:\\Tools\\xtest-src.xml", document);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         values = read(document, maindecls);
         newDoc = createEmptyDocument();
         write(newDoc, values);
         text = writeToString(newDoc);
         System.err.println(text);
         try {
             saveDocument("D:\\Tools\\xtest.xml", newDoc);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         try {
             newDoc = getDocument("D:\\Tools\\xtest.xml");
         } catch (IOException e) {
             e.printStackTrace();
             return;
         } catch (DocumentException e) {
             e.printStackTrace();
             return;
         }
         values = read(newDoc, maindecls);
         hash = new XmlHash(values);
         value = hash.get("n10");
         if (value != null) {
             if (!value.isMultiple()) {
                 XmlValue[] subvalues = value.getSubXml();
                 XmlHash subhash = new XmlHash(subvalues);
                 value = subhash.get("n12");
                 try {
                     value.addFromString("10.3");
                 } catch (InvalidObjectException e) {
                     e.printStackTrace();
                 }
             }
         }
         value = hash.get("n20");
         if (value != null) {
             if (value.isMultiple()) {
                 List<XmlValue[]> listvalues = (List<XmlValue[]>)value.getList();
                 XmlValue[] subvalues = listvalues.get(0);
                 XmlValue[] subvalues2 = new XmlValue[subvalues.length];
                 // Create a perfect clone
                 for (int i = 0; i < subvalues.length; i++) {
                     subvalues2[i] = new XmlValue(subvalues[i]);
                 }
                 // Add it at the end
                 listvalues.add(subvalues2);
                 XmlHash subhash = new XmlHash(subvalues2);
                 value = subhash.get("n21");
                 try {
                     value.setValue(Boolean.FALSE);
                 } catch (InvalidObjectException e) {
                     e.printStackTrace();
                 }
             }
         }
         newDoc = createEmptyDocument();
         write(newDoc, values);
         try {
             saveDocument("D:\\Tools\\xtest2.xml", newDoc);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
         elt = null;
         try {
             elt = getElement(newDoc, "/root/sub9");
         } catch (DocumentException e1) {
             e1.printStackTrace();
             return;
         }
         try {
             saveElement("D:\\Tools\\xtest5.xml",
                     elt);
         } catch (IOException e) {
             e.printStackTrace();
             return;
         }
     }
 
     /**
      * Write the given XML document to filename using the encoding
      * @param filename
      * @param encoding if null, default encoding ISO-8859-1 will be used
      * @param document
      * @throws IOException 
      */
     public static void writeXML(String filename, String encoding, Document document) throws IOException {
         OutputFormat format = OutputFormat.createPrettyPrint();
         if (encoding != null) {
             format.setEncoding(encoding);
         } else {
             format.setEncoding("ISO-8859-1");
         }
         XMLWriter writer = null;
         writer = new XMLWriter(new FileWriter(filename), format);
         writer.write(document);
         try {
             writer.close();
         } catch (IOException e) {
         }
     }
 }