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 import java.io.IOException;
  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.linuxtools.tmf.core.filter.model.ITmfFilterTreeNode;
  29 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterAndNode;
  30 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterCompareNode;
  31 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterContainsNode;
  32 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterEqualsNode;
  33 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterEventTypeNode;
  34 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterMatchesNode;
  35 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterNode;
  36 import org.eclipse.linuxtools.tmf.core.filter.model.TmfFilterOrNode;
  37 import org.w3c.dom.Document;
  38 import org.w3c.dom.Element;
  39
  40 /**
  41  * <b><u>FilterXMLParser</u></b>
  42  * <p>
  43  * This is SAX based XML parser
  44  * <p>
  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
  55          */
  56         public TmfFilterXMLWriter(final ITmfFilterTreeNode root) throws IOException, ParserConfigurationException {
  57                 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
  58                 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
  59                 document = documentBuilder.newDocument();
  60
  61                 Element rootElement = document.createElement(root.getNodeName());
  62                 document.appendChild(rootElement);
  63
  64                 for (ITmfFilterTreeNode node : root.getChildren()) {
  65                         buildXMLTree(document, node, rootElement);
  66                 }
  67         }
  68
  69         /**
  70          * The Tree to XML parser
  71          *
  72          * @param document The XML document
  73          * @param treenode The node to write
  74          * @param parentElement The XML element of the parent
  75          */
  76         public static void buildXMLTree(final Document document, final ITmfFilterTreeNode treenode, Element parentElement) {
  77                 Element element = document.createElement(treenode.getNodeName());
  78
  79                 if (treenode instanceof TmfFilterNode) {
  80
  81                         TmfFilterNode node = (TmfFilterNode) treenode;
  82                         element.setAttribute(TmfFilterNode.NAME_ATTR, node.getFilterName());
  83
  84                 } else if (treenode instanceof TmfFilterEventTypeNode) {
  85
  86                         TmfFilterEventTypeNode node = (TmfFilterEventTypeNode) treenode;
  87                         element.setAttribute(TmfFilterEventTypeNode.TYPE_ATTR, node.getEventType());
  88                         element.setAttribute(TmfFilterEventTypeNode.NAME_ATTR, node.getName());
  89
  90                 } else if (treenode instanceof TmfFilterAndNode) {
  91
  92                         TmfFilterAndNode node = (TmfFilterAndNode) treenode;
  93                         element.setAttribute(TmfFilterAndNode.NOT_ATTR, Boolean.toString(node.isNot()));
  94
  95                 } else if (treenode instanceof TmfFilterOrNode) {
  96
  97                         TmfFilterOrNode node = (TmfFilterOrNode) treenode;
  98                         element.setAttribute(TmfFilterOrNode.NOT_ATTR, Boolean.toString(node.isNot()));
  99
 100                 } else if (treenode instanceof TmfFilterContainsNode) {
 101
 102                         TmfFilterContainsNode node = (TmfFilterContainsNode) treenode;
 103                         element.setAttribute(TmfFilterContainsNode.NOT_ATTR, Boolean.toString(node.isNot()));
 104                         element.setAttribute(TmfFilterContainsNode.FIELD_ATTR, node.getField());
 105                         element.setAttribute(TmfFilterContainsNode.VALUE_ATTR, node.getValue());
 106                         element.setAttribute(TmfFilterContainsNode.IGNORECASE_ATTR, Boolean.toString(node.isIgnoreCase()));
 107
 108                 } else if (treenode instanceof TmfFilterEqualsNode) {
 109
 110                         TmfFilterEqualsNode node = (TmfFilterEqualsNode) treenode;
 111                         element.setAttribute(TmfFilterEqualsNode.NOT_ATTR, Boolean.toString(node.isNot()));
 112                         element.setAttribute(TmfFilterEqualsNode.FIELD_ATTR, node.getField());
 113                         element.setAttribute(TmfFilterEqualsNode.VALUE_ATTR, node.getValue());
 114                         element.setAttribute(TmfFilterEqualsNode.IGNORECASE_ATTR, Boolean.toString(node.isIgnoreCase()));
 115
 116                 } else if (treenode instanceof TmfFilterMatchesNode) {
 117
 118                         TmfFilterMatchesNode node = (TmfFilterMatchesNode) treenode;
 119                         element.setAttribute(TmfFilterMatchesNode.NOT_ATTR, Boolean.toString(node.isNot()));
 120                         element.setAttribute(TmfFilterMatchesNode.FIELD_ATTR, node.getField());
 121                         element.setAttribute(TmfFilterMatchesNode.REGEX_ATTR, node.getRegex());
 122
 123                 } else if (treenode instanceof TmfFilterCompareNode) {
 124
 125                         TmfFilterCompareNode node = (TmfFilterCompareNode) treenode;
 126                         element.setAttribute(TmfFilterCompareNode.NOT_ATTR, Boolean.toString(node.isNot()));
 127                         element.setAttribute(TmfFilterCompareNode.FIELD_ATTR, node.getField());
 128                         element.setAttribute(TmfFilterCompareNode.RESULT_ATTR, Integer.toString(node.getResult()));
 129                         element.setAttribute(TmfFilterCompareNode.TYPE_ATTR, node.getType().toString());
 130                         element.setAttribute(TmfFilterCompareNode.VALUE_ATTR, node.getValue());
 131
 132                 }
 133
 134                 parentElement.appendChild(element);
 135
 136                 for (int i = 0; i < treenode.getChildrenCount(); i++) {
 137                         buildXMLTree(document, treenode.getChild(i), element);
 138                 }
 139         }
 140
 141         /**
 142          * Save the tree
 143          *
 144          * @param uri The new Filter XML path
 145          */
 146         public void saveTree(final String uri) {
 147                 TransformerFactory transformerFactory = TransformerFactory.newInstance();
 148
 149                 try {
 150                         Transformer transformer = transformerFactory.newTransformer();
 151                 DOMSource source = new DOMSource(document);
 152                 StreamResult result =  new StreamResult(new File(uri));
 153                         transformer.transform(source, result);
 154                 } catch (TransformerConfigurationException e) {
 155                         e.printStackTrace();
 156                 } catch (TransformerException e) {
 157                         e.printStackTrace();
 158                 }
 159         }
 160
 161 }