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

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