org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/filter/xml/TmfFilterXMLWriter.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Yuriy Vashchuk (yvashchuk@gmail.com) - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.core.filter.xml;
  14
  15 import java.io.File;
  16
  17 import javax.xml.parsers.DocumentBuilder;
  18 import javax.xml.parsers.DocumentBuilderFactory;
  19 import javax.xml.parsers.ParserConfigurationException;
  20 import javax.xml.transform.Transformer;
  21 import javax.xml.transform.TransformerConfigurationException;
  22 import javax.xml.transform.TransformerException;
  23 import javax.xml.transform.TransformerFactory;
  24 import javax.xml.transform.dom.DOMSource;
  25 import javax.xml.transform.stream.StreamResult;
  26
  27 import org.eclipse.linuxtools.tmf.core.filter.model.ITmfFilterTreeNode;
  28 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterAndNode;
  29 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterCompareNode;
  30 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterContainsNode;
  31 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterEqualsNode;
  32 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterEventTypeNode;
  33 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterMatchesNode;
  34 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterNode;
  35 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterOrNode;
  36 import org.w3c.dom.Document;
  37 import org.w3c.dom.Element;
  38
  39 /**
  40  * The SAX based XML writer
  41  *
  42  * @version 1.0
  43  * @author Yuriy Vashchuk
  44  * @author Patrick Tasse
  45  */
  46 public class TmfFilterXMLWriter {
  47
  48         private Document document = null;
  49
  50         /**
  51          * The XMLParser constructor
  52          *
  53      * @param root The tree root
  54          * @throws ParserConfigurationException if a DocumentBuilder
  55      *   cannot be created which satisfies the configuration requested.
  56          */
  57         public TmfFilterXMLWriter(final ITmfFilterTreeNode root) throws ParserConfigurationException {
  58                 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
  59                 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
  60                 document = documentBuilder.newDocument();
  61
  62                 Element rootElement = document.createElement(root.getNodeName());
  63                 document.appendChild(rootElement);
  64
  65                 for (ITmfFilterTreeNode node : root.getChildren()) {
  66                         buildXMLTree(document, node, rootElement);
  67                 }
  68         }
  69
  70         /**
  71          * The Tree to XML parser
  72          *
  73          * @param document The XML document
  74          * @param treenode The node to write
  75          * @param parentElement The XML element of the parent
  76          */
  77         public static void buildXMLTree(final Document document, final ITmfFilterTreeNode treenode, Element parentElement) {
  78                 Element element = document.createElement(treenode.getNodeName());
  79
  80                 if (treenode instanceof TmfFilterNode) {
  81
  82                         TmfFilterNode node = (TmfFilterNode) treenode;
  83                         element.setAttribute(TmfFilterNode.NAME_ATTR, node.getFilterName());
  84
  85                 } else if (treenode instanceof TmfFilterEventTypeNode) {
  86
  87                         TmfFilterEventTypeNode node = (TmfFilterEventTypeNode) treenode;
  88                         element.setAttribute(TmfFilterEventTypeNode.TYPE_ATTR, node.getEventType());
  89                         element.setAttribute(TmfFilterEventTypeNode.NAME_ATTR, node.getName());
  90
  91                 } else if (treenode instanceof TmfFilterAndNode) {
  92
  93                         TmfFilterAndNode node = (TmfFilterAndNode) treenode;
  94                         element.setAttribute(TmfFilterAndNode.NOT_ATTR, Boolean.toString(node.isNot()));
  95
  96                 } else if (treenode instanceof TmfFilterOrNode) {
  97
  98                         TmfFilterOrNode node = (TmfFilterOrNode) treenode;
  99                         element.setAttribute(TmfFilterOrNode.NOT_ATTR, Boolean.toString(node.isNot()));
 100
 101                 } else if (treenode instanceof TmfFilterContainsNode) {
 102
 103                         TmfFilterContainsNode node = (TmfFilterContainsNode) treenode;
 104                         element.setAttribute(TmfFilterContainsNode.NOT_ATTR, Boolean.toString(node.isNot()));
 105                         element.setAttribute(TmfFilterContainsNode.FIELD_ATTR, node.getField());
 106                         element.setAttribute(TmfFilterContainsNode.VALUE_ATTR, node.getValue());
 107                         element.setAttribute(TmfFilterContainsNode.IGNORECASE_ATTR, Boolean.toString(node.isIgnoreCase()));
 108
 109                 } else if (treenode instanceof TmfFilterEqualsNode) {
 110
 111                         TmfFilterEqualsNode node = (TmfFilterEqualsNode) treenode;
 112                         element.setAttribute(TmfFilterEqualsNode.NOT_ATTR, Boolean.toString(node.isNot()));
 113                         element.setAttribute(TmfFilterEqualsNode.FIELD_ATTR, node.getField());
 114                         element.setAttribute(TmfFilterEqualsNode.VALUE_ATTR, node.getValue());
 115                         element.setAttribute(TmfFilterEqualsNode.IGNORECASE_ATTR, Boolean.toString(node.isIgnoreCase()));
 116
 117                 } else if (treenode instanceof TmfFilterMatchesNode) {
 118
 119                         TmfFilterMatchesNode node = (TmfFilterMatchesNode) treenode;
 120                         element.setAttribute(TmfFilterMatchesNode.NOT_ATTR, Boolean.toString(node.isNot()));
 121                         element.setAttribute(TmfFilterMatchesNode.FIELD_ATTR, node.getField());
 122                         element.setAttribute(TmfFilterMatchesNode.REGEX_ATTR, node.getRegex());
 123
 124                 } else if (treenode instanceof TmfFilterCompareNode) {
 125
 126                         TmfFilterCompareNode node = (TmfFilterCompareNode) treenode;
 127                         element.setAttribute(TmfFilterCompareNode.NOT_ATTR, Boolean.toString(node.isNot()));
 128                         element.setAttribute(TmfFilterCompareNode.FIELD_ATTR, node.getField());
 129                         element.setAttribute(TmfFilterCompareNode.RESULT_ATTR, Integer.toString(node.getResult()));
 130                         element.setAttribute(TmfFilterCompareNode.TYPE_ATTR, node.getType().toString());
 131                         element.setAttribute(TmfFilterCompareNode.VALUE_ATTR, node.getValue());
 132
 133                 }
 134
 135                 parentElement.appendChild(element);
 136
 137                 for (int i = 0; i < treenode.getChildrenCount(); i++) {
 138                         buildXMLTree(document, treenode.getChild(i), element);
 139                 }
 140         }
 141
 142         /**
 143          * Save the tree
 144          *
 145          * @param uri The new Filter XML path
 146          */
 147         public void saveTree(final String uri) {
 148                 TransformerFactory transformerFactory = TransformerFactory.newInstance();
 149
 150                 try {
 151                         Transformer transformer = transformerFactory.newTransformer();
 152                 DOMSource source = new DOMSource(document);
 153                 StreamResult result =  new StreamResult(new File(uri));
 154                         transformer.transform(source, result);
 155                 } catch (TransformerConfigurationException e) {
 156                         e.printStackTrace();
 157                 } catch (TransformerException e) {
 158                         e.printStackTrace();
 159                 }
 160         }
 161
 162 }