diff -r ed1c9f64298a -r 5b9d4d8641ce trace/traceviewer/com.nokia.traceviewer/src/com/nokia/traceviewer/engine/activation/TraceActivationXMLExporter.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/trace/traceviewer/com.nokia.traceviewer/src/com/nokia/traceviewer/engine/activation/TraceActivationXMLExporter.java Wed Jun 23 14:49:59 2010 +0300 @@ -0,0 +1,411 @@ +/* + * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: + * + * Trace activation information Exporter class + * + */ +package com.nokia.traceviewer.engine.activation; + +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.StringWriter; +import java.util.List; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.OutputKeys; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerConfigurationException; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; + +import org.w3c.dom.Attr; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; +import org.xml.sax.SAXException; + +import com.nokia.traceviewer.engine.TraceViewerGlobals; + +/** + * Trace activation information Exporter class + * + */ +public class TraceActivationXMLExporter { + + /** + * Components that are exported + */ + private final List components; + + /** + * File path to use when exporting + */ + private final String filePath; + + /** + * Configuration name to export + */ + private final String configurationName; + + /** + * Output stream writer + */ + private OutputStreamWriter out; + + /** + * Constructor + * + * @param components + * components + * @param configurationFileName + * file name where to export data + * @param configurationName + * name of the new configuration + */ + public TraceActivationXMLExporter( + List components, + String configurationFileName, String configurationName) { + this.components = components; + this.configurationName = configurationName; + this.filePath = configurationFileName; + + createFile(); + } + + /** + * Exports data + * + * @return true if exporting succeeds + */ + public boolean export() { + boolean succeeded = false; + Document doc = getDocument(); + Node parent; + + if (doc != null) { + + // Get root node of activation rules + NodeList list = doc + .getElementsByTagName(TraceActivationXMLConstants.ACTIVATIONS_TAG); + + // Doesn't exist, create + if (list.getLength() == 0) { + parent = doc + .createElement(TraceActivationXMLConstants.ACTIVATIONS_TAG); + try { + doc.appendChild(parent); + } catch (Exception e) { + parent = null; + } + } else { + parent = list.item(0); + } + + // Search if given activation name already exists and delete it + if (parent != null) { + NodeList activations = parent.getChildNodes(); + for (int i = 0; i < activations.getLength(); i++) { + if (activations.item(i) instanceof Element) { + NamedNodeMap itemAttributes = activations.item(i) + .getAttributes(); + + // Get name + Attr nameAttr = (Attr) itemAttributes + .getNamedItem(TraceActivationXMLConstants.NAME_TAG); + String name = nameAttr.getValue(); + if (name.equals(configurationName)) { + parent.removeChild(activations.item(i)); + break; + } + } + } + + // Create new activation and process components to it + Node newActivation = doc + .createElement(TraceActivationXMLConstants.ACTIVATION_TAG); + parent.appendChild(newActivation); + + // Set name + NamedNodeMap itemAttributes = newActivation.getAttributes(); + Attr name = doc + .createAttribute(TraceActivationXMLConstants.NAME_TAG); + name.setValue(configurationName); + itemAttributes.setNamedItem(name); + for (int j = 0; j < components.size(); j++) { + processComponent(components.get(j), doc, newActivation); + } + + // Get result from document + StreamResult result = getResultFromDocument(doc); + + // Print out + String xmlString = result.getWriter().toString(); + writeFile(xmlString); + succeeded = true; + } else { + // If comes here, root node "activation" was not found and + // couldn't be created + String cannotSave = Messages + .getString("TraceActivationXMLExporter.CannotSaveToTheFile"); //$NON-NLS-1$ + TraceViewerGlobals.getTraceViewer().getDialogs() + .showErrorMessage(cannotSave); + } + } else { + // If comes here, file was not found + String fileNotFound = Messages + .getString("TraceActivationXMLExporter.CannotSaveToTheFile"); //$NON-NLS-1$ + TraceViewerGlobals.getTraceViewer().getDialogs().showErrorMessage( + fileNotFound); + } + + return succeeded; + } + + /** + * Removes given configuration + */ + public void remove() { + Document doc = getDocument(); + Node parent; + + if (doc != null) { + + // Get root node of activation rules + NodeList list = doc + .getElementsByTagName(TraceActivationXMLConstants.ACTIVATIONS_TAG); + parent = list.item(0); + + // Search if given activation name already exists and delete it + if (parent != null) { + NodeList activations = parent.getChildNodes(); + for (int i = 0; i < activations.getLength(); i++) { + if (activations.item(i) instanceof Element) { + NamedNodeMap itemAttributes = activations.item(i) + .getAttributes(); + + // Get name + Attr nameAttr = (Attr) itemAttributes + .getNamedItem(TraceActivationXMLConstants.NAME_TAG); + String name = nameAttr.getValue(); + if (name.equals(configurationName)) { + parent.removeChild(activations.item(i)); + break; + } + } + } + } + + // Get result from document + StreamResult result = getResultFromDocument(doc); + + // Print out + String xmlString = result.getWriter().toString(); + writeFile(xmlString); + } + } + + /** + * Process component + * + * @param item + * component to process + * @param doc + * document + * @param root + * node to insert this child to + */ + private void processComponent(TraceActivationComponentItem item, + Document doc, Node root) { + // Process through the component + Node newItem = null; + newItem = doc.createElement(TraceActivationXMLConstants.COMPONENT_TAG); + + // Get attributes + NamedNodeMap itemAttributes = newItem.getAttributes(); + + // Set ID + Attr id = doc.createAttribute(TraceActivationXMLConstants.ID_TAG); + id.setValue(String.valueOf(item.getId())); + itemAttributes.setNamedItem(id); + + // Set as child to parent + root.appendChild(newItem); + + // Loop through groups in this component + List groups = item.getGroups(); + for (int i = 0; i < groups.size(); i++) { + + // Create new group node + Node newGroup = doc + .createElement(TraceActivationXMLConstants.GROUP_TAG); + + // Get attributes + NamedNodeMap attributes = newGroup.getAttributes(); + + // Set ID + Attr groupId = doc + .createAttribute(TraceActivationXMLConstants.ID_TAG); + groupId.setValue(String.valueOf(groups.get(i).getId())); + attributes.setNamedItem(groupId); + + // Set activation value + if (groups.get(i).isActivated()) { + newGroup.setTextContent(TraceActivationXMLConstants.YES_TAG); + } else { + newGroup.setTextContent(TraceActivationXMLConstants.NO_TAG); + } + + // Set as child to parent + newItem.appendChild(newGroup); + } + } + + /** + * Creates the file + */ + public void createFile() { + File file = new File(filePath); + + // File doesn't exist, create it + if (!file.exists() || file.length() == 0) { + createFileSkeleton(); + } else { + // File exists + } + } + + /** + * Creates XML file skeleton + */ + private void createFileSkeleton() { + try { + // Open an Output Stream Writer to set encoding + OutputStream fout = new FileOutputStream(filePath); + OutputStream bout = new BufferedOutputStream(fout); + out = new OutputStreamWriter(bout, "UTF-8"); //$NON-NLS-1$ + + out.write(TraceActivationXMLConstants.XML_HEADER); + out.write(TraceActivationXMLConstants.FILE_START); + out.write(TraceActivationXMLConstants.ACTIVATIONS_START); + out.write(TraceActivationXMLConstants.ACTIVATIONS_END); + out.write(TraceActivationXMLConstants.FILE_END); + out.flush(); + out.close(); + } catch (IOException e) { + } + + } + + /** + * Writes ready XML string to file + * + * @param xmlString + */ + protected void writeFile(String xmlString) { + + try { + // Open an Output Stream Writer to set encoding + OutputStream fout = new FileOutputStream(filePath); + OutputStream bout = new BufferedOutputStream(fout); + out = new OutputStreamWriter(bout, "UTF-8"); //$NON-NLS-1$ + + } catch (IOException e) { + e.printStackTrace(); + } + try { + out.write(xmlString); + out.flush(); + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * Gets result from document + * + * @param doc + * document + * @return result + */ + protected StreamResult getResultFromDocument(Document doc) { + TransformerFactory tf = TransformerFactory.newInstance(); + int indentSize = 2; + tf.setAttribute("indent-number", Integer.valueOf((indentSize))); //$NON-NLS-1$ + Transformer transformer = null; + try { + transformer = tf.newTransformer(); + } catch (TransformerConfigurationException e1) { + e1.printStackTrace(); + } + if (transformer != null) { + transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$ + } + + // initialize StreamResult with File object to save to file + StreamResult result = new StreamResult(new StringWriter()); + DOMSource source = new DOMSource(doc); + try { + if (transformer != null) { + transformer.transform(source, result); + } + } catch (TransformerException e) { + e.printStackTrace(); + } + return result; + } + + /** + * Gets DOM document for the file path + * + * @return document + */ + protected Document getDocument() { + DocumentBuilderFactory docFactory = DocumentBuilderFactory + .newInstance(); + DocumentBuilder docBuilder = null; + try { + docBuilder = docFactory.newDocumentBuilder(); + } catch (ParserConfigurationException e) { + e.printStackTrace(); + } + + // Get the document + Document doc = null; + try { + if (docBuilder != null) { + File file = new File(filePath); + if (file.exists()) { + doc = docBuilder.parse(filePath); + } + } + } catch (SAXException e1) { + e1.printStackTrace(); + } catch (IOException e1) { + e1.printStackTrace(); + } + return doc; + } +}