Attachment #65218 for bug #163352

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 12-17 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/wizards/LogSetManager.java (-1 / +72 lines)
12		12
13	package org.eclipse.tptp.monitoring.logui.internal.wizards;	13	package org.eclipse.tptp.monitoring.logui.internal.wizards;
14		14
		15	import java.io.ByteArrayOutputStream;
15	import java.net.URL;	16	import java.net.URL;
16	import java.util.ArrayList;	17	import java.util.ArrayList;
17	import java.util.HashMap;	18	import java.util.HashMap;
Lines 26-36 Link Here
26	import org.eclipse.core.runtime.Status;	27	import org.eclipse.core.runtime.Status;
27	import org.eclipse.emf.common.util.URI;	28	import org.eclipse.emf.common.util.URI;
28	import org.eclipse.emf.ecore.util.EcoreUtil;	29	import org.eclipse.emf.ecore.util.EcoreUtil;
		30	import org.eclipse.emf.ecore.xmi.XMLResource;
29	import org.eclipse.hyades.internal.execution.local.common.Constants;	31	import org.eclipse.hyades.internal.execution.local.common.Constants;
30	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;	32	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;
31	import org.eclipse.hyades.ui.filters.IFilterScopes;	33	import org.eclipse.hyades.ui.filters.IFilterScopes;
32	import org.eclipse.hyades.ui.filters.internal.util.FilterInformationManager;	34	import org.eclipse.hyades.ui.filters.internal.util.FilterInformationManager;
33	import org.eclipse.hyades.ui.filters.internal.util.FilterQueries;	35	import org.eclipse.hyades.ui.filters.internal.util.FilterQueries;
		36	import org.eclipse.hyades.ui.filters.internal.util.FilterResourceFileHandler;
		37	import org.eclipse.hyades.ui.filters.internal.util.FilterResourceHandler;
34	import org.eclipse.hyades.ui.internal.util.XMLUtil;	38	import org.eclipse.hyades.ui.internal.util.XMLUtil;
35		39
36	import org.eclipse.jface.preference.IPreferenceStore;	40	import org.eclipse.jface.preference.IPreferenceStore;
Lines 50-56 Link Here
50	public static final String LOGSET_TAG = "logset";	54	public static final String LOGSET_TAG = "logset";
51	public static final String LOGELEMENT_TAG = "LogFileElement";	55	public static final String LOGELEMENT_TAG = "LogFileElement";
52	public static final String DEFAULT_LOGSET = LogUIMessages._54;	56	public static final String DEFAULT_LOGSET = LogUIMessages._54;
53		57	public static final String FILTER_TAG = "filters";
		58	public static final String EXPORT_URI="/temp.txt";
		59	public static final Map RESOURCE_OPTIONS = new HashMap();
		60	{
		61	RESOURCE_OPTIONS.put(XMLResource.OPTION_DECLARE_XML, Boolean.FALSE);
		62	}
54	private IPreferenceStore preferenceStore = MonitoringLogUIPlugin.getDefault().getPreferenceStore();	63	private IPreferenceStore preferenceStore = MonitoringLogUIPlugin.getDefault().getPreferenceStore();
55	private String defaultLogSet;	64	private String defaultLogSet;
56	private Map logSetsList = new HashMap();	65	private Map logSetsList = new HashMap();
Lines 87-93 Link Here
87	loadParserRegistry();	96	loadParserRegistry();
88		97
89	}	98	}
		99	public void saveLogSetFilters(List logSetFilterList) {
		100	FilterResourceHandler rTarget = FilterResourceHandler.instance(); //list of all existing filters
		101	Object[] targetFilterQueries = rTarget.toArray();
		102	if(targetFilterQueries.length > 0){
		103	for (int i = 0; i < targetFilterQueries.length; i++)
		104	{
		105	FilterQueries existingFQ = (FilterQueries) targetFilterQueries[i];
		106	if(existingFQ != null){
		107	String targetFilterName = (existingFQ).name();
		108	for (Iterator iter = logSetFilterList.iterator(); iter.hasNext();) {
		109	FilterQueries fq = (FilterQueries) iter.next();
		110	if(fq != null){
		111	if(targetFilterName.equals(fq.name())){
		112	rTarget.removeFilter(existingFQ);
		113	}
		114	rTarget.addFilter(fq);
		115	}
		116	}
		117	}
		118	}
		119	}
		120	else{
		121	for (Iterator iter = logSetFilterList.iterator(); iter.hasNext();) {
		122	FilterQueries fq = (FilterQueries) iter.next();
		123	if(fq != null){
		124	rTarget.addFilter(fq);
		125	}
		126	}
		127	}
		128	rTarget.save();
		129	}
90		130
		131	public String generateLogSetFilterDefEntry(List logSetFilterList){
		132	if (logSetFilterList != null && (logSetFilterList.size() > 0)) {
		133	StringBuffer xmlString = new StringBuffer();
		134	xmlString.append(" <");
		135	xmlString.append(FILTER_TAG);
		136	xmlString.append("> ");
		137	FilterResourceFileHandler rtarget = FilterResourceFileHandler.instance(URI.createFileURI(EXPORT_URI));
		138	rtarget.clear();
		139	for (Iterator iter = logSetFilterList.iterator(); iter.hasNext();) {
		140	FilterQueries fq = (FilterQueries)iter.next();
		141	if(fq != null){
		142	rtarget.addFilter(fq.copy());
		143	}
		144	}
		145	if (rtarget instanceof XMLResource) {
		146	((XMLResource) rtarget).setEncoding("UTF-8");
		147	}
		148	ByteArrayOutputStream oStream = new ByteArrayOutputStream();
		149	rtarget.save(oStream, RESOURCE_OPTIONS);
		150	byte[] b = oStream.toByteArray();
		151	String filterStr = new String(b);
		152	xmlString.append(filterStr);
		153	xmlString.append(" </");
		154	xmlString.append(FILTER_TAG);
		155	xmlString.append("> ");
		156	return xmlString.toString();
		157
		158	}
		159	return "";
		160	}
		161
91	public void loadLogSets(){	162	public void loadLogSets(){
92		163
93	String prefXML = preferenceStore.getString(LOGSETS_KEY);	164	String prefXML = preferenceStore.getString(LOGSETS_KEY);

Lines 23-28 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/wizards/ExportLogSetsUI.java (-14 / +49 lines)
23	import java.util.List;	23	import java.util.List;
24		24
25	import org.eclipse.core.runtime.Path;	25	import org.eclipse.core.runtime.Path;
		26	import org.eclipse.hyades.ui.filters.internal.util.FilterQueries;
		27	import org.eclipse.hyades.ui.filters.internal.util.FilterResourceHandler;
26	import org.eclipse.hyades.ui.internal.util.ContextIds;	28	import org.eclipse.hyades.ui.internal.util.ContextIds;
27	import org.eclipse.hyades.ui.internal.util.XMLUtil;	29	import org.eclipse.hyades.ui.internal.util.XMLUtil;
28	import org.eclipse.jface.dialogs.IDialogConstants;	30	import org.eclipse.jface.dialogs.IDialogConstants;
Lines 32-37 Link Here
32	import org.eclipse.swt.widgets.Composite;	34	import org.eclipse.swt.widgets.Composite;
33	import org.eclipse.tptp.monitoring.logui.internal.LogUIMessages;	35	import org.eclipse.tptp.monitoring.logui.internal.LogUIMessages;
34	import org.eclipse.tptp.monitoring.logui.internal.MonitoringLogUIPlugin;	36	import org.eclipse.tptp.monitoring.logui.internal.MonitoringLogUIPlugin;
		37	import org.eclipse.tptp.monitoring.logui.internal.util.FilterTransformationHelper;
		38	import org.eclipse.tptp.monitoring.logui.internal.wizards.LogFileElement.Filter;
35	import org.eclipse.tptp.platform.common.ui.internal.CommonUIPlugin;	39	import org.eclipse.tptp.platform.common.ui.internal.CommonUIPlugin;
36	import org.eclipse.ui.PlatformUI;	40	import org.eclipse.ui.PlatformUI;
37	import org.eclipse.ui.dialogs.IOverwriteQuery;	41	import org.eclipse.ui.dialogs.IOverwriteQuery;
Lines 47-73 Link Here
47		51
48	public boolean finish() {	52	public boolean finish() {
49		53
50	StringBuffer xmlString = new StringBuffer();	54	StringBuffer xmiString = new StringBuffer();
51		55
52	xmlString.append("<?xml");	56	xmiString.append("<?xml");
53	xmlString.append(XMLUtil.createXMLAttribute("version","1.0", false)).append(XMLUtil.createXMLAttribute("encoding","UTF-8", false));	57	xmiString.append(XMLUtil.createXMLAttribute("version","1.0", false)).append(XMLUtil.createXMLAttribute("encoding","UTF-8", false));
54	xmlString.append("?>");	58	xmiString.append("?>");
55		59
56	xmlString.append(" <");	60	xmiString.append(" <");
57	xmlString.append(LogSetManager.LOGSETS_KEY);	61	xmiString.append(LogSetManager.LOGSETS_KEY);
58	xmlString.append("> ");	62	xmiString.append("> ");
59		63
60	Iterator keySet = getDoubleList().getTargetItems().iterator();	64	Iterator keySet = getDoubleList().getTargetItems().iterator();
61	String key = "";	65	String key = "";
		66	List filterList = new ArrayList();
62	while(keySet.hasNext()) {	67	while(keySet.hasNext()) {
63	key = (String) keySet.next();	68	key = (String) keySet.next();
64	xmlString.append(lsMgr.generateLogSetPrefEntry(key));	69	xmiString.append(lsMgr.generateLogSetPrefEntry(key));
		70	populateLogSetFilterList(key,filterList);
65	}	71	}
		72	xmiString.append(lsMgr.generateLogSetFilterDefEntry(filterList));
		73	xmiString.append(" </");
		74	xmiString.append(LogSetManager.LOGSETS_KEY);
		75	xmiString.append(">");
66		76
67	xmlString.append(" </");	77	String xmlString = FilterTransformationHelper.convertXmiToXml(xmiString.toString());
68	xmlString.append(LogSetManager.LOGSETS_KEY);	78
69	xmlString.append(">");
70
71	String filePath = sourceNameField.getText().trim();	79	String filePath = sourceNameField.getText().trim();
72	if (!filePath.endsWith(".logsxml"))	80	if (!filePath.endsWith(".logsxml"))
73	filePath += ".logsxml";	81	filePath += ".logsxml";
Lines 100-106 Link Here
100	writer.close();	108	writer.close();
101		109
102	} catch (IOException ioException) {	110	} catch (IOException ioException) {
103	ioException.printStackTrace();
104	MonitoringLogUIPlugin.log(ioException);	111	MonitoringLogUIPlugin.log(ioException);
105	return false;	112	return false;
106	}	113	}
Lines 108-113 Link Here
108	return true;	115	return true;
109	}	116	}
110		117
		118	protected void populateLogSetFilterList(String key,List filterList){
		119	List logSet = (List) lsMgr.getLogSets().get(key);
		120	if (logSet != null) {
		121	LogFileElement element = null;
		122	Filter filter = null;
		123	for (Iterator iter1 = logSet.iterator(); iter1.hasNext();) {
		124	element = (LogFileElement) iter1.next();
		125	filter = element.getFilter();
		126	if (filter != null) {
		127	String filterName = filter.getName();
		128	FilterQueries fq = FilterResourceHandler.instance().filter(filterName);
		129	if(fq != null){
		130	boolean flag = true;
		131	for (Iterator iter2 = filterList.iterator(); iter2.hasNext();) {
		132	if(((FilterQueries)iter2.next()).name().equals(fq.name())){
		133	flag = false;
		134	break;
		135	}
		136	}
		137	if(flag){
		138	filterList.add(fq);
		139	}
		140	}
		141	}
		142	}
		143	}
		144	}
		145
111	protected List populateFilterList() {	146	protected List populateFilterList() {
112		147
113	lsMgr = LogSetManager.getInstance();	148	lsMgr = LogSetManager.getInstance();

Lines 12-23 Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/wizards/ImportLogSetsUI.java (-1 / +99 lines)
12		12
13	package org.eclipse.tptp.monitoring.logui.internal.wizards;	13	package org.eclipse.tptp.monitoring.logui.internal.wizards;
14		14
		15	import java.io.ByteArrayInputStream;
15	import java.io.File;	16	import java.io.File;
16	import java.io.FileInputStream;	17	import java.io.FileInputStream;
17	import java.io.IOException;	18	import java.io.IOException;
		19	import java.io.InputStream;
		20	import java.io.StringReader;
18	import java.util.ArrayList;	21	import java.util.ArrayList;
		22	import java.util.Iterator;
19	import java.util.List;	23	import java.util.List;
20		24
		25	import javax.xml.parsers.DocumentBuilderFactory;
		26	import org.eclipse.emf.common.util.URI;
		27	import org.eclipse.hyades.ui.filters.internal.util.FilterQueries;
		28	import org.eclipse.hyades.ui.filters.internal.util.FilterResourceFileHandler;
21	import org.eclipse.hyades.ui.internal.util.ContextIds;	29	import org.eclipse.hyades.ui.internal.util.ContextIds;
22	import org.eclipse.hyades.ui.internal.util.XMLUtil;	30	import org.eclipse.hyades.ui.internal.util.XMLUtil;
23	import org.eclipse.jface.dialogs.IMessageProvider;	31	import org.eclipse.jface.dialogs.IMessageProvider;
Lines 26-35 Link Here
26	import org.eclipse.swt.widgets.Composite;	34	import org.eclipse.swt.widgets.Composite;
27	import org.eclipse.tptp.monitoring.logui.internal.LogUIMessages;	35	import org.eclipse.tptp.monitoring.logui.internal.LogUIMessages;
28	import org.eclipse.tptp.monitoring.logui.internal.MonitoringLogUIPlugin;	36	import org.eclipse.tptp.monitoring.logui.internal.MonitoringLogUIPlugin;
		37	import org.eclipse.tptp.monitoring.logui.internal.util.FilterTransformationHelper;
29	import org.eclipse.tptp.platform.common.ui.internal.CommonUIPlugin;	38	import org.eclipse.tptp.platform.common.ui.internal.CommonUIPlugin;
30	import org.eclipse.ui.PlatformUI;	39	import org.eclipse.ui.PlatformUI;
		40	import org.w3c.dom.Document;
31	import org.w3c.dom.Element;	41	import org.w3c.dom.Element;
		42	import org.w3c.dom.Node;
32	import org.w3c.dom.NodeList;	43	import org.w3c.dom.NodeList;
		44	import org.xml.sax.InputSource;
33		45
34	public class ImportLogSetsUI extends ImportExportLogSetsUI {	46	public class ImportLogSetsUI extends ImportExportLogSetsUI {
35		47
Lines 45-68 Link Here
45	public boolean finish() {	57	public boolean finish() {
46		58
47	List list = doubleList.getTargetItems();	59	List list = doubleList.getTargetItems();
		60	List filterList = new ArrayList();
		61	FilterResourceFileHandler rSource = populateLogSetFilterXML();
48	String name=null;	62	String name=null;
49	for(int idx=0; idx<list.size(); idx++)	63	for(int idx=0; idx<list.size(); idx++)
50	{	64	{
51	Element elem = (Element)list.get(idx);	65	Element elem = (Element)list.get(idx);
52		66
53	if(idx==0)	67	if(idx==0)
		68	{
54	name = elem.getAttribute("name");	69	name = elem.getAttribute("name");
55	lsMgr.loadLogSet(elem);	70	}
		71
		72	if(rSource != null)
		73	{
		74	populateLogSetFilterList(rSource,elem,filterList);
		75	}
		76
		77	lsMgr.loadLogSet(elem);
56	}	78	}
57		79
		80	if(filterList.size() > 0)
		81	lsMgr.saveLogSetFilters(filterList);
		82
		83	if(rSource != null)
		84	rSource.clear();
		85
58	if(name != null)	86	if(name != null)
59	{	87	{
60	lsMgr.setDefaultLogSet(name);	88	lsMgr.setDefaultLogSet(name);
61	lsMgr.openLogSet(name);	89	lsMgr.openLogSet(name);
62	}	90	}
		91
63	return true;	92	return true;
64	}	93	}
65		94
		95	private void populateLogSetFilterList(FilterResourceFileHandler rSource , Element elem,List filterList){
		96	NodeList logNodeList = XMLUtil.getChildrenByName(elem,LogSetManager.LOGELEMENT_TAG);
		97	Element element = null;
		98	for (int i = 0, maxi = logNodeList.getLength(); i < maxi; i++) {
		99	if (logNodeList.item(i) instanceof Element) {
		100	element = (Element) logNodeList.item(i);
		101	NodeList filterNodes = XMLUtil.getChildrenByName(element, "filter");
		102	if (filterNodes != null && filterNodes.getLength() > 0) {
		103	if (filterNodes.item(0) instanceof Element) {
		104	String filterName = ((Element) filterNodes.item(0)).getAttribute("name");
		105	FilterQueries fq = rSource.filter(filterName);
		106	if(fq != null){
		107	boolean flag = true;
		108	for (Iterator iter2 = filterList.iterator(); iter2.hasNext();) {
		109	if(((FilterQueries)iter2.next()).name().equals(fq.name())){
		110	flag = false;
		111	break;
		112	}
		113	}
		114	if(flag){
		115	filterList.add(fq);
		116	}
		117	}
		118	}
		119	}
		120	}
		121
		122	}
		123	}
		124
		125	protected FilterResourceFileHandler populateLogSetFilterXML()
		126	{
		127	String fileName = sourceNameField.getText().trim();
		128	Node filterNode = null;
		129	if ((new File(fileName)).exists())
		130	{
		131	try {
		132	FileInputStream inputStream = new FileInputStream(fileName);
		133	Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream);
		134	Element root = doc.getDocumentElement();
		135	String xmlString = FilterTransformationHelper.toString(root);
		136
		137	String xmiString = FilterTransformationHelper.convertXmlToXmi(xmlString);
		138
		139	doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(new StringReader(xmiString)));
		140	Element elem = doc.getDocumentElement();
		141	NodeList nl = elem.getChildNodes();
		142	for(int l1 = 0; l1 < nl.getLength(); l1++)
		143	{
		144	if(nl.item(l1).getNodeName().equals(LogSetManager.FILTER_TAG))
		145	{
		146	filterNode = (Element)nl.item(l1);
		147	FilterResourceFileHandler rSource = FilterResourceFileHandler.instance(URI.createFileURI(fileName)); //filters list to store new imported filters
		148	rSource.clear();
		149
		150	InputStream is = new ByteArrayInputStream(FilterTransformationHelper.toString(filterNode).getBytes());
		151	rSource.load(is, LogSetManager.RESOURCE_OPTIONS);
		152	return rSource;
		153	}
		154	}
		155	}
		156	catch(Exception exception)
		157	{
		158	MonitoringLogUIPlugin.log(exception);
159	}
160	}
161	return null;
162	}
163
66	protected List populateFilterList()	164	protected List populateFilterList()
67	{	165	{
68	String fileName = sourceNameField.getText().trim();	166	String fileName = sourceNameField.getText().trim();




/**********************************************************************
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: FilterTransformationHelper.java,v 1.11 2007/03/21 21:30:59 
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/
package org.eclipse.tptp.monitoring.logui.internal.util;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.XMLSerializer;
import org.eclipse.tptp.monitoring.logui.internal.MonitoringLogUIPlugin;

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.InputSource;

public class FilterTransformationHelper 
{
	public static String convertXmiToXml(String xmiString)
	{
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		try
		{
			DocumentBuilder builder = factory.newDocumentBuilder();
			
			Document document = builder.parse(new InputSource(new StringReader(xmiString)));
			
			Document newDocument = builder.newDocument();
				
			Element element = (Element) document.getElementsByTagName("logsets").item(0);
			if(element != null)
			{
				buildXMLDocument(element, null, newDocument);
			}
			
			Node root = newDocument.getElementsByTagName("logsets").item(0);
			
			return 	toString(root);
		}
		catch (Exception e) 
		{
			MonitoringLogUIPlugin.log(e);
			return null;
		}
	}
	
	private static void buildXMLDocument(Element element, Element parent, Document newDocument)
	{
		String nodeName = element.getNodeName();
		if(!nodeName.equals("xmi:XMI"))
		{
			if(nodeName.equals("HierarchyExtensions:SimpleSearchQuery"))
			{
				nodeName = "LogAnalyzerFilter";
			}
			
			Element newElement = newDocument.createElement(nodeName);
			
			newElement.setTextContent(element.getTextContent());
			
			NamedNodeMap attributes = element.getAttributes();
			for(int i = 0; i < attributes.getLength(); i++)
			{
				Node attribute = attributes.item(i);
				String name = attribute.getNodeName();
				if(name.equals("xsi:type"))
				{
					name = "category";
				}
				else if(nodeName.equals("valueType") && name.equals("href"))
				{
					name = "type";
				}
				
				String value = attribute.getNodeValue();
				if(value.startsWith("HierarchyExtensions:"))
				{
					value = value.replace("HierarchyExtensions:", "Hierarchial");
				}
				else if(value.startsWith("ecore:E"))
				{
					value = value.replace("ecore:E", "Event:");
				}
				else if(value.contains("http://www.eclipse.org"))
				{
					value = value.replace("http://www.eclipse.org/emf/2002/Ecore#//E", "");
				}
				else if(value.startsWith("org.eclipse.hyades.log.ui.ImportLogFilterType:"))
				{
					value = value.replace("org.eclipse.hyades.log.ui.ImportLogFilterType:", "ImportLogFilterType:");
				}
				
				newElement.setAttribute(name, value);
			}
			
			if(parent == null)
			{
				newDocument.appendChild(newElement);
			}
			else
			{
				parent.appendChild(newElement);
			}
			
			parent = newElement;
		}

		NodeList children = element.getChildNodes();
		for(int i = 0; i < children.getLength(); i++)
		{
			Object object = children.item(i);
			if(object instanceof Element)
			{
				Element child = (Element) object;
				if(child != null)
				{
					buildXMLDocument(child, parent, newDocument);
				}
			}
		}
	}

	public static String convertXmlToXmi(String xmlString)
	{
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		try
		{
			DocumentBuilder builder = factory.newDocumentBuilder();
			
			Document document = builder.parse(new InputSource(new StringReader(xmlString)));
			
			Document newDocument = builder.newDocument();
				
			Element element = (Element) document.getElementsByTagName("logsets").item(0);
			if(element != null)
			{
				buildXmiDocument(element, null, newDocument);
			}
			
			Node root = newDocument.getElementsByTagName("logsets").item(0);
			
			return 	toString(root);
		}
		catch (Exception e) 
		{
			MonitoringLogUIPlugin.log(e);
			return null;
		}
	}
	
	private static void buildXmiDocument(Element element, Element parent, Document newDocument)
	{
		String nodeName = element.getNodeName();
		
		if(nodeName.equals("LogAnalyzerFilter"))
		{
			nodeName = "HierarchyExtensions:SimpleSearchQuery";
		}
		
		Element newElement = newDocument.createElement(nodeName);
		
		newElement.setTextContent(element.getTextContent());
		
		NamedNodeMap attributes = element.getAttributes();
		for(int i = 0; i < attributes.getLength(); i++)
		{
			Node attribute = attributes.item(i);
			String name = attribute.getNodeName();
			if(name.equals("category"))
			{
				name = "xsi:type";
			}
			else if(nodeName.equals("valueType") && name.equals("type"))
			{
				name = "href";
			}
			
			String value = attribute.getNodeValue();
			if(value.startsWith("Hierarchial"))
			{
				value = value.replace("Hierarchial", "HierarchyExtensions:");
			}
			else if(value.startsWith("Event:"))
			{
				value = value.replace("Event:", "ecore:E");
			}
			else if(nodeName.equals("valueType") && name.equals("href"))
			{
				value = "http://www.eclipse.org/emf/2002/Ecore#//E" + value;
			}
			else if(value.startsWith("ImportLogFilterType:"))
			{
				value = value.replace("ImportLogFilterType:", "org.eclipse.hyades.log.ui.ImportLogFilterType:");
			}
			
			newElement.setAttribute(name, value);
		}
		
		if(parent == null)
		{
			newDocument.appendChild(newElement);
		}
		else
		{
			parent.appendChild(newElement);
		}
		parent = newElement;
		
		if(nodeName.equals("filters"))
		{
			Element xmiElement = newDocument.createElement("xmi:XMI");
			
			xmiElement.setAttribute("xmi:version", "2.0");
			xmiElement.setAttribute("xmlns:xmi", "http://www.omg.org/XMI");
			xmiElement.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
			xmiElement.setAttribute("xmlns:HierarchyExtensions", "http://www.eclipse.org/hyades/models/hierarchy-extensions.xmi");
			xmiElement.setAttribute("xmlns:ecore", "http://www.eclipse.org/emf/2002/Ecore");
			
			parent.appendChild(xmiElement);
			
			parent = xmiElement;
		}

		NodeList children = element.getChildNodes();
		for(int i = 0; i < children.getLength(); i++)
		{
			Object object = children.item(i);
			if(object instanceof Element)
			{
				Element child = (Element) object;
				if(child != null)
				{
					buildXmiDocument(child, parent, newDocument);
				}
			}
		}
	}

	public static String toString(Node xml)
	{
		return toString(xml, true);
	}

	public static String toString(Node xml, boolean printHeader) 
	{
		return toString(xml, printHeader, true);
	}

	public static String toString(Node xml, boolean printHeader, boolean printIndents) 
	{
		short type = xml.getNodeType();
		if (type == 3) 
		{
			return xml.getNodeValue();
		}
		
		XMLSerializer serializer = new XMLSerializer();
		serializer.setNamespaces(true);
		OutputFormat formatter = new OutputFormat();
		formatter.setOmitXMLDeclaration(!printHeader);
		formatter.setIndenting(printIndents);
		serializer.setOutputFormat(formatter);
		StringWriter writer = new StringWriter();
		serializer.setOutputCharStream(writer);
		
		try 
		{
			if (type == 9) 
			{
				serializer.serialize((Document) xml);
			} 
			else 
			{
				serializer.serialize((Element) xml);
			}
		} 
		catch (IOException error) 
		{
			throw new RuntimeException(error.getMessage(), error);
		}
		
		return writer.toString();
	}
}

Return to bug 163352

Added Link Here

(-)src/org/eclipse/tptp/monitoring/logui/internal/util/FilterTransformationHelper.java (+299 lines)
1	/**********************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: FilterTransformationHelper.java,v 1.11 2007/03/21 21:30:59
8	*
9	* Contributors:
10	* IBM - Initial API and implementation
11	**********************************************************************/
12	package org.eclipse.tptp.monitoring.logui.internal.util;
13
14	import java.io.IOException;
15	import java.io.StringReader;
16	import java.io.StringWriter;
17
18	import javax.xml.parsers.DocumentBuilder;
19	import javax.xml.parsers.DocumentBuilderFactory;
20
21	import org.apache.xml.serialize.OutputFormat;
22	import org.apache.xml.serialize.XMLSerializer;
23	import org.eclipse.tptp.monitoring.logui.internal.MonitoringLogUIPlugin;
24
25	import org.w3c.dom.Document;
26	import org.w3c.dom.Element;
27	import org.w3c.dom.NamedNodeMap;
28	import org.w3c.dom.Node;
29	import org.w3c.dom.NodeList;
30	import org.xml.sax.InputSource;
31
32	public class FilterTransformationHelper
33	{
34	public static String convertXmiToXml(String xmiString)
35	{
36	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
37	try
38	{
39	DocumentBuilder builder = factory.newDocumentBuilder();
40
41	Document document = builder.parse(new InputSource(new StringReader(xmiString)));
42
43	Document newDocument = builder.newDocument();
44
45	Element element = (Element) document.getElementsByTagName("logsets").item(0);
46	if(element != null)
47	{
48	buildXMLDocument(element, null, newDocument);
49	}
50
51	Node root = newDocument.getElementsByTagName("logsets").item(0);
52
53	return toString(root);
54	}
55	catch (Exception e)
56	{
57	MonitoringLogUIPlugin.log(e);
58	return null;
59	}
60	}
61
62	private static void buildXMLDocument(Element element, Element parent, Document newDocument)
63	{
64	String nodeName = element.getNodeName();
65	if(!nodeName.equals("xmi:XMI"))
66	{
67	if(nodeName.equals("HierarchyExtensions:SimpleSearchQuery"))
68	{
69	nodeName = "LogAnalyzerFilter";
70	}
71
72	Element newElement = newDocument.createElement(nodeName);
73
74	newElement.setTextContent(element.getTextContent());
75
76	NamedNodeMap attributes = element.getAttributes();
77	for(int i = 0; i < attributes.getLength(); i++)
78	{
79	Node attribute = attributes.item(i);
80	String name = attribute.getNodeName();
81	if(name.equals("xsi:type"))
82	{
83	name = "category";
84	}
85	else if(nodeName.equals("valueType") && name.equals("href"))
86	{
87	name = "type";
88	}
89
90	String value = attribute.getNodeValue();
91	if(value.startsWith("HierarchyExtensions:"))
92	{
93	value = value.replace("HierarchyExtensions:", "Hierarchial");
94	}
95	else if(value.startsWith("ecore:E"))
96	{
97	value = value.replace("ecore:E", "Event:");
98	}
99	else if(value.contains("http://www.eclipse.org"))
100	{
101	value = value.replace("http://www.eclipse.org/emf/2002/Ecore#//E", "");
102	}
103	else if(value.startsWith("org.eclipse.hyades.log.ui.ImportLogFilterType:"))
104	{
105	value = value.replace("org.eclipse.hyades.log.ui.ImportLogFilterType:", "ImportLogFilterType:");
106	}
107
108	newElement.setAttribute(name, value);
109	}
110
111	if(parent == null)
112	{
113	newDocument.appendChild(newElement);
114	}
115	else
116	{
117	parent.appendChild(newElement);
118	}
119
120	parent = newElement;
121	}
122
123	NodeList children = element.getChildNodes();
124	for(int i = 0; i < children.getLength(); i++)
125	{
126	Object object = children.item(i);
127	if(object instanceof Element)
128	{
129	Element child = (Element) object;
130	if(child != null)
131	{
132	buildXMLDocument(child, parent, newDocument);
133	}
134	}
135	}
136	}
137
138	public static String convertXmlToXmi(String xmlString)
139	{
140	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
141	try
142	{
143	DocumentBuilder builder = factory.newDocumentBuilder();
144
145	Document document = builder.parse(new InputSource(new StringReader(xmlString)));
146
147	Document newDocument = builder.newDocument();
148
149	Element element = (Element) document.getElementsByTagName("logsets").item(0);
150	if(element != null)
151	{
152	buildXmiDocument(element, null, newDocument);
153	}
154
155	Node root = newDocument.getElementsByTagName("logsets").item(0);
156
157	return toString(root);
158	}
159	catch (Exception e)
160	{
161	MonitoringLogUIPlugin.log(e);
162	return null;
163	}
164	}
165
166	private static void buildXmiDocument(Element element, Element parent, Document newDocument)
167	{
168	String nodeName = element.getNodeName();
169
170	if(nodeName.equals("LogAnalyzerFilter"))
171	{
172	nodeName = "HierarchyExtensions:SimpleSearchQuery";
173	}
174
175	Element newElement = newDocument.createElement(nodeName);
176
177	newElement.setTextContent(element.getTextContent());
178
179	NamedNodeMap attributes = element.getAttributes();
180	for(int i = 0; i < attributes.getLength(); i++)
181	{
182	Node attribute = attributes.item(i);
183	String name = attribute.getNodeName();
184	if(name.equals("category"))
185	{
186	name = "xsi:type";
187	}
188	else if(nodeName.equals("valueType") && name.equals("type"))
189	{
190	name = "href";
191	}
192
193	String value = attribute.getNodeValue();
194	if(value.startsWith("Hierarchial"))
195	{
196	value = value.replace("Hierarchial", "HierarchyExtensions:");
197	}
198	else if(value.startsWith("Event:"))
199	{
200	value = value.replace("Event:", "ecore:E");
201	}
202	else if(nodeName.equals("valueType") && name.equals("href"))
203	{
204	value = "http://www.eclipse.org/emf/2002/Ecore#//E" + value;
205	}
206	else if(value.startsWith("ImportLogFilterType:"))
207	{
208	value = value.replace("ImportLogFilterType:", "org.eclipse.hyades.log.ui.ImportLogFilterType:");
209	}
210
211	newElement.setAttribute(name, value);
212	}
213
214	if(parent == null)
215	{
216	newDocument.appendChild(newElement);
217	}
218	else
219	{
220	parent.appendChild(newElement);
221	}
222	parent = newElement;
223
224	if(nodeName.equals("filters"))
225	{
226	Element xmiElement = newDocument.createElement("xmi:XMI");
227
228	xmiElement.setAttribute("xmi:version", "2.0");
229	xmiElement.setAttribute("xmlns:xmi", "http://www.omg.org/XMI");
230	xmiElement.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
231	xmiElement.setAttribute("xmlns:HierarchyExtensions", "http://www.eclipse.org/hyades/models/hierarchy-extensions.xmi");
232	xmiElement.setAttribute("xmlns:ecore", "http://www.eclipse.org/emf/2002/Ecore");
233
234	parent.appendChild(xmiElement);
235
236	parent = xmiElement;
237	}
238
239	NodeList children = element.getChildNodes();
240	for(int i = 0; i < children.getLength(); i++)
241	{
242	Object object = children.item(i);
243	if(object instanceof Element)
244	{
245	Element child = (Element) object;
246	if(child != null)
247	{
248	buildXmiDocument(child, parent, newDocument);
249	}
250	}
251	}
252	}
253
254	public static String toString(Node xml)
255	{
256	return toString(xml, true);
257	}
258
259	public static String toString(Node xml, boolean printHeader)
260	{
261	return toString(xml, printHeader, true);
262	}
263
264	public static String toString(Node xml, boolean printHeader, boolean printIndents)
265	{
266	short type = xml.getNodeType();
267	if (type == 3)
268	{
269	return xml.getNodeValue();
270	}
271
272	XMLSerializer serializer = new XMLSerializer();
273	serializer.setNamespaces(true);
274	OutputFormat formatter = new OutputFormat();
275	formatter.setOmitXMLDeclaration(!printHeader);
276	formatter.setIndenting(printIndents);
277	serializer.setOutputFormat(formatter);
278	StringWriter writer = new StringWriter();
279	serializer.setOutputCharStream(writer);
280
281	try
282	{
283	if (type == 9)
284	{
285	serializer.serialize((Document) xml);
286	}
287	else
288	{
289	serializer.serialize((Element) xml);
290	}
291	}
292	catch (IOException error)
293	{
294	throw new RuntimeException(error.getMessage(), error);
295	}
296
297	return writer.toString();
298	}
299	}