org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/parsers/custom/CustomTxtTraceDefinition.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  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.parsers.custom;
  14
  15 import java.io.ByteArrayInputStream;
  16 import java.io.File;
  17 import java.io.FileWriter;
  18 import java.io.IOException;
  19 import java.io.StringWriter;
  20 import java.util.ArrayList;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.regex.Pattern;
  24 import java.util.regex.PatternSyntaxException;
  25
  26 import javax.xml.parsers.DocumentBuilder;
  27 import javax.xml.parsers.DocumentBuilderFactory;
  28 import javax.xml.parsers.ParserConfigurationException;
  29 import javax.xml.transform.OutputKeys;
  30 import javax.xml.transform.Transformer;
  31 import javax.xml.transform.TransformerConfigurationException;
  32 import javax.xml.transform.TransformerException;
  33 import javax.xml.transform.TransformerFactory;
  34 import javax.xml.transform.TransformerFactoryConfigurationError;
  35 import javax.xml.transform.dom.DOMSource;
  36 import javax.xml.transform.stream.StreamResult;
  37
  38 import org.eclipse.linuxtools.tmf.ui.TmfUiPlugin;
  39 import org.w3c.dom.Document;
  40 import org.w3c.dom.Element;
  41 import org.w3c.dom.Node;
  42 import org.w3c.dom.NodeList;
  43 import org.xml.sax.EntityResolver;
  44 import org.xml.sax.ErrorHandler;
  45 import org.xml.sax.InputSource;
  46 import org.xml.sax.SAXException;
  47 import org.xml.sax.SAXParseException;
  48
  49 public class CustomTxtTraceDefinition extends CustomTraceDefinition {
  50
  51     protected static final String CUSTOM_TXT_TRACE_DEFINITIONS_FILE_NAME = "custom_txt_parsers.xml";
  52     protected static final String CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME =
  53         TmfUiPlugin.getDefault().getStateLocation().addTrailingSeparator().append(CUSTOM_TXT_TRACE_DEFINITIONS_FILE_NAME).toString();
  54
  55     private static final String CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT = "CustomTxtTraceDefinitionList";
  56     private static final String DEFINITION_ELEMENT = "Definition";
  57     private static final String NAME_ATTRIBUTE = "name";
  58     private static final String TIME_STAMP_OUTPUT_FORMAT_ELEMENT = "TimeStampOutputFormat";
  59     private static final String INPUT_LINE_ELEMENT = "InputLine";
  60     private static final String CARDINALITY_ELEMENT = "Cardinality";
  61     private static final String MIN_ATTRIBUTE = "min";
  62     private static final String MAX_ATTRIBUTE = "max";
  63     private static final String REGEX_ELEMENT = "RegEx";
  64     private static final String INPUT_DATA_ELEMENT = "InputData";
  65     private static final String ACTION_ATTRIBUTE = "action";
  66     private static final String FORMAT_ATTRIBUTE = "format";
  67     private static final String OUTPUT_COLUMN_ELEMENT = "OutputColumn";
  68
  69     public List<InputLine> inputs;
  70
  71     public CustomTxtTraceDefinition() {
  72         this("", new ArrayList<InputLine>(0), new ArrayList<OutputColumn>(0), "");
  73     };
  74
  75     public CustomTxtTraceDefinition(String logtype, List<InputLine> inputs, List<OutputColumn> outputs, String timeStampOutputFormat) {
  76         this.definitionName = logtype;
  77         this.inputs = inputs;
  78         this.outputs = outputs;
  79         this.timeStampOutputFormat = timeStampOutputFormat;
  80     }
  81
  82     public static class InputLine {
  83         public List<InputData> columns;
  84         public Cardinality cardinality;
  85         private String regex;
  86         private Pattern pattern;
  87         public InputLine parentInput;
  88         public int level;
  89         public InputLine nextInput;
  90         public List<InputLine> childrenInputs;
  91
  92         public InputLine() {};
  93
  94         public InputLine(Cardinality cardinality, String regex, List<InputData> columns) {
  95             this.cardinality = cardinality;
  96             this.regex = regex;
  97             this.columns = columns;
  98         }
  99
 100         public void setRegex(String regex) {
 101             this.regex = regex;
 102             this.pattern = null;
 103         }
 104
 105         public String getRegex() {
 106             return regex;
 107         }
 108
 109         public Pattern getPattern() throws PatternSyntaxException {
 110             if (pattern == null) {
 111                 pattern = Pattern.compile(regex);
 112             }
 113             return pattern;
 114         }
 115
 116         public void addChild(InputLine input) {
 117             if (childrenInputs == null) {
 118                 childrenInputs = new ArrayList<InputLine>(1);
 119             } else if (childrenInputs.size() > 0) {
 120                 InputLine last = childrenInputs.get(childrenInputs.size() - 1);
 121                 last.nextInput = input;
 122             }
 123             childrenInputs.add(input);
 124             input.parentInput = this;
 125             input.level = this.level + 1;
 126         }
 127
 128         public void addNext(InputLine input) {
 129             if (parentInput != null) {
 130                 int index = parentInput.childrenInputs.indexOf(this);
 131                 parentInput.childrenInputs.add(index + 1, input);
 132                 InputLine next = nextInput;
 133                 nextInput = input;
 134                 input.nextInput = next;
 135             }
 136             input.parentInput = this.parentInput;
 137             input.level = this.level;
 138         }
 139
 140         public void moveUp() {
 141             if (parentInput != null) {
 142                 int index = parentInput.childrenInputs.indexOf(this);
 143                 if (index > 0) {
 144                     parentInput.childrenInputs.add(index - 1 , parentInput.childrenInputs.remove(index));
 145                     parentInput.childrenInputs.get(index).nextInput = nextInput;
 146                     nextInput = parentInput.childrenInputs.get(index);
 147                 }
 148             }
 149         }
 150
 151         public void moveDown() {
 152             if (parentInput != null) {
 153                 int index = parentInput.childrenInputs.indexOf(this);
 154                 if (index < parentInput.childrenInputs.size() - 1) {
 155                     parentInput.childrenInputs.add(index + 1 , parentInput.childrenInputs.remove(index));
 156                     nextInput = parentInput.childrenInputs.get(index).nextInput;
 157                     parentInput.childrenInputs.get(index).nextInput = this;
 158                 }
 159             }
 160         }
 161
 162         public void addColumn(InputData column) {
 163             if (columns == null) {
 164                 columns = new ArrayList<InputData>(1);
 165             }
 166             columns.add(column);
 167         }
 168
 169         public List<InputLine> getNextInputs(Map<InputLine, Integer> countMap) {
 170             List<InputLine> nextInputs = new ArrayList<InputLine>();
 171             InputLine next = nextInput;
 172             while (next != null) {
 173                 nextInputs.add(next);
 174                 if (next.cardinality.min > 0) {
 175                     return nextInputs;
 176                 }
 177                 next = next.nextInput;
 178             }
 179             if (parentInput != null && parentInput.level > 0) {
 180                 int parentCount = countMap.get(parentInput);
 181                 if (parentCount < parentInput.getMaxCount()) {
 182                     nextInputs.add(parentInput);
 183                 }
 184                 if (parentCount < parentInput.getMinCount()) {
 185                     return nextInputs;
 186                 }
 187                 nextInputs.addAll(parentInput.getNextInputs(countMap));
 188             }
 189             return nextInputs;
 190         }
 191
 192         public int getMinCount() {
 193             return cardinality.min;
 194         }
 195
 196         public int getMaxCount() {
 197             return cardinality.max;
 198         }
 199
 200         @Override
 201         public String toString() {
 202             return regex + " " + cardinality;
 203         }
 204
 205     }
 206
 207     public static class InputData {
 208         public String name;
 209         public int action;
 210         public String format;
 211
 212         public InputData() {};
 213
 214         public InputData(String name, int action, String format) {
 215             this.name = name;
 216             this.action = action;
 217             this.format = format;
 218         }
 219
 220         public InputData(String name, int action) {
 221             this.name = name;
 222             this.action = action;
 223         }
 224     }
 225
 226     public static class Cardinality {
 227         public final static int INF = Integer.MAX_VALUE;
 228         public final static Cardinality ONE = new Cardinality(1, 1);
 229         public final static Cardinality ONE_OR_MORE = new Cardinality(1, INF);
 230         public final static Cardinality ZERO_OR_ONE = new Cardinality(0, 1);
 231         public final static Cardinality ZERO_OR_MORE = new Cardinality(0, INF);
 232
 233         private int min;
 234         private int max;
 235
 236         public Cardinality(int min, int max) {
 237             this.min = min;
 238             this.max = max;
 239         }
 240
 241         @Override
 242         public String toString() {
 243             return "(" + (min >= 0 ? min : "?") + "," + (max == INF ? "\u221E" : (max >= 0 ? max : "?")) + ")";
 244         }
 245
 246         @Override
 247         public boolean equals(Object obj) {
 248             if (!(obj instanceof Cardinality)) return false;
 249             Cardinality other = (Cardinality) obj;
 250             return (this.min == other.min && this.max == other.max);
 251         }
 252     }
 253
 254     @Override
 255         public void save() {
 256         save(CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME);
 257     }
 258
 259     @Override
 260         public void save(String path) {
 261         try {
 262             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 263             DocumentBuilder db = dbf.newDocumentBuilder();
 264
 265             // The following allows xml parsing without access to the dtd
 266             EntityResolver resolver = new EntityResolver () {
 267                 public InputSource resolveEntity (String publicId, String systemId) {
 268                     String empty = "";
 269                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 270                     return new InputSource(bais);
 271                 }
 272             };
 273             db.setEntityResolver(resolver);
 274
 275             // The following catches xml parsing exceptions
 276             db.setErrorHandler(new ErrorHandler(){
 277                 public void error(SAXParseException saxparseexception) throws SAXException {}
 278                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 279                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 280                     throw saxparseexception;
 281                 }});
 282
 283             Document doc = null;
 284             File file = new File(path);
 285             if (file.canRead()) {
 286                 doc = db.parse(file);
 287                 if (! doc.getDocumentElement().getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 288                     return;
 289                 }
 290             } else {
 291                 doc = db.newDocument();
 292                 Node node = doc.createElement(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT);
 293                 doc.appendChild(node);
 294             }
 295
 296             Element root = doc.getDocumentElement();
 297
 298             NodeList nodeList = root.getChildNodes();
 299             for (int i = 0; i < nodeList.getLength(); i++) {
 300                 Node node = nodeList.item(i);
 301                 if (node instanceof Element &&
 302                         node.getNodeName().equals(DEFINITION_ELEMENT) &&
 303                         definitionName.equals(((Element) node).getAttribute(NAME_ATTRIBUTE))) {
 304                     root.removeChild(node);
 305                 }
 306             }
 307             Element definitionElement = doc.createElement(DEFINITION_ELEMENT);
 308             root.appendChild(definitionElement);
 309             definitionElement.setAttribute(NAME_ATTRIBUTE, definitionName);
 310
 311             Element formatElement = doc.createElement(TIME_STAMP_OUTPUT_FORMAT_ELEMENT);
 312             definitionElement.appendChild(formatElement);
 313             formatElement.appendChild(doc.createTextNode(timeStampOutputFormat));
 314
 315             if (inputs != null) {
 316                 for (InputLine inputLine : inputs) {
 317                     definitionElement.appendChild(createInputLineElement(inputLine, doc));
 318                 }
 319             }
 320
 321             if (outputs != null) {
 322                 for (OutputColumn output : outputs) {
 323                     Element outputColumnElement = doc.createElement(OUTPUT_COLUMN_ELEMENT);
 324                     definitionElement.appendChild(outputColumnElement);
 325                     outputColumnElement.setAttribute(NAME_ATTRIBUTE, output.name);
 326                 }
 327             }
 328
 329             Transformer transformer = TransformerFactory.newInstance().newTransformer();
 330             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 331
 332             //initialize StreamResult with File object to save to file
 333             StreamResult result = new StreamResult(new StringWriter());
 334             DOMSource source = new DOMSource(doc);
 335             transformer.transform(source, result);
 336             String xmlString = result.getWriter().toString();
 337
 338             FileWriter writer = new FileWriter(file);
 339             writer.write(xmlString);
 340             writer.close();
 341         } catch (ParserConfigurationException e) {
 342             e.printStackTrace();
 343         } catch (TransformerConfigurationException e) {
 344             e.printStackTrace();
 345         } catch (TransformerFactoryConfigurationError e) {
 346             e.printStackTrace();
 347         } catch (TransformerException e) {
 348             e.printStackTrace();
 349         } catch (IOException e) {
 350             e.printStackTrace();
 351         } catch (SAXException e) {
 352             e.printStackTrace();
 353         }
 354     }
 355
 356     private Element createInputLineElement(InputLine inputLine, Document doc) {
 357         Element inputLineElement = doc.createElement(INPUT_LINE_ELEMENT);
 358
 359         Element cardinalityElement = doc.createElement(CARDINALITY_ELEMENT);
 360         inputLineElement.appendChild(cardinalityElement);
 361         cardinalityElement.setAttribute(MIN_ATTRIBUTE, Integer.toString(inputLine.cardinality.min));
 362         cardinalityElement.setAttribute(MAX_ATTRIBUTE, Integer.toString(inputLine.cardinality.max));
 363
 364         Element regexElement = doc.createElement(REGEX_ELEMENT);
 365         inputLineElement.appendChild(regexElement);
 366         regexElement.appendChild(doc.createTextNode(inputLine.regex));
 367
 368         if (inputLine.columns != null) {
 369             for (InputData inputData : inputLine.columns) {
 370                 Element inputDataElement = doc.createElement(INPUT_DATA_ELEMENT);
 371                 inputLineElement.appendChild(inputDataElement);
 372                 inputDataElement.setAttribute(NAME_ATTRIBUTE, inputData.name);
 373                 inputDataElement.setAttribute(ACTION_ATTRIBUTE, Integer.toString(inputData.action));
 374                 if (inputData.format != null) {
 375                     inputDataElement.setAttribute(FORMAT_ATTRIBUTE, inputData.format);
 376                 }
 377             }
 378         }
 379
 380         if (inputLine.childrenInputs != null) {
 381             for (InputLine childInputLine : inputLine.childrenInputs) {
 382                 inputLineElement.appendChild(createInputLineElement(childInputLine, doc));
 383             }
 384         }
 385
 386         return inputLineElement;
 387     }
 388
 389     public static CustomTxtTraceDefinition[] loadAll() {
 390         return loadAll(CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME);
 391     }
 392
 393     public static CustomTxtTraceDefinition[] loadAll(String path) {
 394         try {
 395             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 396             DocumentBuilder db = dbf.newDocumentBuilder();
 397
 398             // The following allows xml parsing without access to the dtd
 399             EntityResolver resolver = new EntityResolver () {
 400                 public InputSource resolveEntity (String publicId, String systemId) {
 401                     String empty = "";
 402                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 403                     return new InputSource(bais);
 404                 }
 405             };
 406             db.setEntityResolver(resolver);
 407
 408             // The following catches xml parsing exceptions
 409             db.setErrorHandler(new ErrorHandler(){
 410                 public void error(SAXParseException saxparseexception) throws SAXException {}
 411                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 412                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 413                     throw saxparseexception;
 414                 }});
 415
 416             File file = new File(path);
 417             if (!file.canRead()) {
 418                 return new CustomTxtTraceDefinition[0];
 419             }
 420             Document doc = db.parse(file);
 421
 422             Element root = doc.getDocumentElement();
 423             if (! root.getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 424                 return new CustomTxtTraceDefinition[0];
 425             }
 426
 427             ArrayList<CustomTxtTraceDefinition> defList = new ArrayList<CustomTxtTraceDefinition>();
 428             NodeList nodeList = root.getChildNodes();
 429             for (int i = 0; i < nodeList.getLength(); i++) {
 430                 Node node = nodeList.item(i);
 431                 if (node instanceof Element && node.getNodeName().equals(DEFINITION_ELEMENT)) {
 432                     CustomTxtTraceDefinition def = extractDefinition((Element) node);
 433                     if (def != null) {
 434                         defList.add(def);
 435                     }
 436                 }
 437             }
 438             return defList.toArray(new CustomTxtTraceDefinition[0]);
 439         } catch (ParserConfigurationException e) {
 440             e.printStackTrace();
 441         } catch (SAXException e) {
 442             e.printStackTrace();
 443         } catch (IOException e) {
 444             e.printStackTrace();
 445         }
 446         return new CustomTxtTraceDefinition[0];
 447     }
 448
 449     public static CustomTxtTraceDefinition load(String definitionName) {
 450         try {
 451             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 452             DocumentBuilder db = dbf.newDocumentBuilder();
 453
 454             // The following allows xml parsing without access to the dtd
 455             EntityResolver resolver = new EntityResolver () {
 456                 public InputSource resolveEntity (String publicId, String systemId) {
 457                     String empty = "";
 458                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 459                     return new InputSource(bais);
 460                 }
 461             };
 462             db.setEntityResolver(resolver);
 463
 464             // The following catches xml parsing exceptions
 465             db.setErrorHandler(new ErrorHandler(){
 466                 public void error(SAXParseException saxparseexception) throws SAXException {}
 467                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 468                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 469                     throw saxparseexception;
 470                 }});
 471
 472             File file = new File(CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME);
 473             Document doc = db.parse(file);
 474
 475             Element root = doc.getDocumentElement();
 476             if (! root.getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 477                 return null;
 478             }
 479
 480             NodeList nodeList = root.getChildNodes();
 481             for (int i = 0; i < nodeList.getLength(); i++) {
 482                 Node node = nodeList.item(i);
 483                 if (node instanceof Element &&
 484                         node.getNodeName().equals(DEFINITION_ELEMENT) &&
 485                         definitionName.equals(((Element) node).getAttribute(NAME_ATTRIBUTE))) {
 486                     return extractDefinition((Element) node);
 487                 }
 488             }
 489         } catch (ParserConfigurationException e) {
 490             e.printStackTrace();
 491         } catch (SAXException e) {
 492             e.printStackTrace();
 493         } catch (IOException e) {
 494             e.printStackTrace();
 495         }
 496         return null;
 497     }
 498
 499     public static CustomTxtTraceDefinition extractDefinition(Element definitionElement) {
 500         CustomTxtTraceDefinition def = new CustomTxtTraceDefinition();
 501
 502         def.definitionName = definitionElement.getAttribute(NAME_ATTRIBUTE);
 503         if (def.definitionName == null) return null;
 504
 505         NodeList nodeList = definitionElement.getChildNodes();
 506         for (int i = 0; i < nodeList.getLength(); i++) {
 507             Node node = nodeList.item(i);
 508             String nodeName = node.getNodeName();
 509             if (nodeName.equals(TIME_STAMP_OUTPUT_FORMAT_ELEMENT)) {
 510                 Element formatElement = (Element) node;
 511                 def.timeStampOutputFormat = formatElement.getTextContent();
 512             } else if (nodeName.equals(INPUT_LINE_ELEMENT)) {
 513                 InputLine inputLine = extractInputLine((Element) node);
 514                 if (inputLine != null) {
 515                     def.inputs.add(inputLine);
 516                 }
 517             } else if (nodeName.equals(OUTPUT_COLUMN_ELEMENT)) {
 518                 Element outputColumnElement = (Element) node;
 519                 OutputColumn outputColumn = new OutputColumn();
 520                 outputColumn.name = outputColumnElement.getAttribute(NAME_ATTRIBUTE);
 521                 def.outputs.add(outputColumn);
 522             }
 523         }
 524         return def;
 525     }
 526
 527     private static InputLine extractInputLine(Element inputLineElement) {
 528         InputLine inputLine = new InputLine();
 529         NodeList nodeList = inputLineElement.getChildNodes();
 530         for (int i = 0; i < nodeList.getLength(); i++) {
 531             Node node = nodeList.item(i);
 532             String nodeName = node.getNodeName();
 533             if (nodeName.equals(CARDINALITY_ELEMENT)) {
 534                 Element cardinalityElement = (Element) node;
 535                 try {
 536                     int min = Integer.parseInt(cardinalityElement.getAttribute(MIN_ATTRIBUTE));
 537                     int max = Integer.parseInt(cardinalityElement.getAttribute(MAX_ATTRIBUTE));
 538                     inputLine.cardinality = new Cardinality(min, max);
 539                 } catch (NumberFormatException e) {
 540                     return null;
 541                 }
 542             } else if (nodeName.equals(REGEX_ELEMENT)) {
 543                 Element regexElement = (Element) node;
 544                 inputLine.regex = regexElement.getTextContent();
 545             } else if (nodeName.equals(INPUT_DATA_ELEMENT)) {
 546                 Element inputDataElement = (Element) node;
 547                 InputData inputData = new InputData();
 548                 inputData.name = inputDataElement.getAttribute(NAME_ATTRIBUTE);
 549                 inputData.action = Integer.parseInt(inputDataElement.getAttribute(ACTION_ATTRIBUTE));
 550                 inputData.format = inputDataElement.getAttribute(FORMAT_ATTRIBUTE);
 551                 inputLine.addColumn(inputData);
 552             } else if (nodeName.equals(INPUT_LINE_ELEMENT)) {
 553                 Element childInputLineElement = (Element) node;
 554                 InputLine childInputLine = extractInputLine(childInputLineElement);
 555                 if (childInputLine != null) {
 556                     inputLine.addChild(childInputLine);
 557                 }
 558             }
 559         }
 560         return inputLine;
 561     }
 562
 563     public static void delete(String definitionName) {
 564         try {
 565             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 566             DocumentBuilder db = dbf.newDocumentBuilder();
 567
 568             // The following allows xml parsing without access to the dtd
 569             EntityResolver resolver = new EntityResolver () {
 570                 public InputSource resolveEntity (String publicId, String systemId) {
 571                     String empty = "";
 572                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 573                     return new InputSource(bais);
 574                 }
 575             };
 576             db.setEntityResolver(resolver);
 577
 578             // The following catches xml parsing exceptions
 579             db.setErrorHandler(new ErrorHandler(){
 580                 public void error(SAXParseException saxparseexception) throws SAXException {}
 581                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 582                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 583                     throw saxparseexception;
 584                 }});
 585
 586             File file = new File(CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME);
 587             Document doc = db.parse(file);
 588
 589             Element root = doc.getDocumentElement();
 590             if (! root.getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 591                 return;
 592             }
 593
 594             NodeList nodeList = root.getChildNodes();
 595             for (int i = 0; i < nodeList.getLength(); i++) {
 596                 Node node = nodeList.item(i);
 597                 if (node instanceof Element &&
 598                         node.getNodeName().equals(DEFINITION_ELEMENT) &&
 599                         definitionName.equals(((Element) node).getAttribute(NAME_ATTRIBUTE))) {
 600                     root.removeChild(node);
 601                 }
 602             }
 603
 604             Transformer transformer = TransformerFactory.newInstance().newTransformer();
 605             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 606
 607             //initialize StreamResult with File object to save to file
 608             StreamResult result = new StreamResult(new StringWriter());
 609             DOMSource source = new DOMSource(doc);
 610             transformer.transform(source, result);
 611             String xmlString = result.getWriter().toString();
 612
 613             FileWriter writer = new FileWriter(file);
 614             writer.write(xmlString);
 615             writer.close();
 616         } catch (ParserConfigurationException e) {
 617             e.printStackTrace();
 618         } catch (SAXException e) {
 619             e.printStackTrace();
 620         } catch (IOException e) {
 621             e.printStackTrace();
 622         } catch (TransformerConfigurationException e) {
 623             e.printStackTrace();
 624         } catch (TransformerFactoryConfigurationError e) {
 625             e.printStackTrace();
 626         } catch (TransformerException e) {
 627             e.printStackTrace();
 628         }
 629     }
 630 }