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                 @Override
 268                 public InputSource resolveEntity (String publicId, String systemId) {
 269                     String empty = "";
 270                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 271                     return new InputSource(bais);
 272                 }
 273             };
 274             db.setEntityResolver(resolver);
 275
 276             // The following catches xml parsing exceptions
 277             db.setErrorHandler(new ErrorHandler(){
 278                 @Override
 279                 public void error(SAXParseException saxparseexception) throws SAXException {}
 280                 @Override
 281                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 282                 @Override
 283                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 284                     throw saxparseexception;
 285                 }});
 286
 287             Document doc = null;
 288             File file = new File(path);
 289             if (file.canRead()) {
 290                 doc = db.parse(file);
 291                 if (! doc.getDocumentElement().getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 292                     return;
 293                 }
 294             } else {
 295                 doc = db.newDocument();
 296                 Node node = doc.createElement(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT);
 297                 doc.appendChild(node);
 298             }
 299
 300             Element root = doc.getDocumentElement();
 301
 302             NodeList nodeList = root.getChildNodes();
 303             for (int i = 0; i < nodeList.getLength(); i++) {
 304                 Node node = nodeList.item(i);
 305                 if (node instanceof Element &&
 306                         node.getNodeName().equals(DEFINITION_ELEMENT) &&
 307                         definitionName.equals(((Element) node).getAttribute(NAME_ATTRIBUTE))) {
 308                     root.removeChild(node);
 309                 }
 310             }
 311             Element definitionElement = doc.createElement(DEFINITION_ELEMENT);
 312             root.appendChild(definitionElement);
 313             definitionElement.setAttribute(NAME_ATTRIBUTE, definitionName);
 314
 315             Element formatElement = doc.createElement(TIME_STAMP_OUTPUT_FORMAT_ELEMENT);
 316             definitionElement.appendChild(formatElement);
 317             formatElement.appendChild(doc.createTextNode(timeStampOutputFormat));
 318
 319             if (inputs != null) {
 320                 for (InputLine inputLine : inputs) {
 321                     definitionElement.appendChild(createInputLineElement(inputLine, doc));
 322                 }
 323             }
 324
 325             if (outputs != null) {
 326                 for (OutputColumn output : outputs) {
 327                     Element outputColumnElement = doc.createElement(OUTPUT_COLUMN_ELEMENT);
 328                     definitionElement.appendChild(outputColumnElement);
 329                     outputColumnElement.setAttribute(NAME_ATTRIBUTE, output.name);
 330                 }
 331             }
 332
 333             Transformer transformer = TransformerFactory.newInstance().newTransformer();
 334             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 335
 336             //initialize StreamResult with File object to save to file
 337             StreamResult result = new StreamResult(new StringWriter());
 338             DOMSource source = new DOMSource(doc);
 339             transformer.transform(source, result);
 340             String xmlString = result.getWriter().toString();
 341
 342             FileWriter writer = new FileWriter(file);
 343             writer.write(xmlString);
 344             writer.close();
 345         } catch (ParserConfigurationException e) {
 346             e.printStackTrace();
 347         } catch (TransformerConfigurationException e) {
 348             e.printStackTrace();
 349         } catch (TransformerFactoryConfigurationError e) {
 350             e.printStackTrace();
 351         } catch (TransformerException e) {
 352             e.printStackTrace();
 353         } catch (IOException e) {
 354             e.printStackTrace();
 355         } catch (SAXException e) {
 356             e.printStackTrace();
 357         }
 358     }
 359
 360     private Element createInputLineElement(InputLine inputLine, Document doc) {
 361         Element inputLineElement = doc.createElement(INPUT_LINE_ELEMENT);
 362
 363         Element cardinalityElement = doc.createElement(CARDINALITY_ELEMENT);
 364         inputLineElement.appendChild(cardinalityElement);
 365         cardinalityElement.setAttribute(MIN_ATTRIBUTE, Integer.toString(inputLine.cardinality.min));
 366         cardinalityElement.setAttribute(MAX_ATTRIBUTE, Integer.toString(inputLine.cardinality.max));
 367
 368         Element regexElement = doc.createElement(REGEX_ELEMENT);
 369         inputLineElement.appendChild(regexElement);
 370         regexElement.appendChild(doc.createTextNode(inputLine.regex));
 371
 372         if (inputLine.columns != null) {
 373             for (InputData inputData : inputLine.columns) {
 374                 Element inputDataElement = doc.createElement(INPUT_DATA_ELEMENT);
 375                 inputLineElement.appendChild(inputDataElement);
 376                 inputDataElement.setAttribute(NAME_ATTRIBUTE, inputData.name);
 377                 inputDataElement.setAttribute(ACTION_ATTRIBUTE, Integer.toString(inputData.action));
 378                 if (inputData.format != null) {
 379                     inputDataElement.setAttribute(FORMAT_ATTRIBUTE, inputData.format);
 380                 }
 381             }
 382         }
 383
 384         if (inputLine.childrenInputs != null) {
 385             for (InputLine childInputLine : inputLine.childrenInputs) {
 386                 inputLineElement.appendChild(createInputLineElement(childInputLine, doc));
 387             }
 388         }
 389
 390         return inputLineElement;
 391     }
 392
 393     public static CustomTxtTraceDefinition[] loadAll() {
 394         return loadAll(CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME);
 395     }
 396
 397     public static CustomTxtTraceDefinition[] loadAll(String path) {
 398         try {
 399             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 400             DocumentBuilder db = dbf.newDocumentBuilder();
 401
 402             // The following allows xml parsing without access to the dtd
 403             EntityResolver resolver = new EntityResolver () {
 404                 @Override
 405                 public InputSource resolveEntity (String publicId, String systemId) {
 406                     String empty = "";
 407                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 408                     return new InputSource(bais);
 409                 }
 410             };
 411             db.setEntityResolver(resolver);
 412
 413             // The following catches xml parsing exceptions
 414             db.setErrorHandler(new ErrorHandler(){
 415                 @Override
 416                 public void error(SAXParseException saxparseexception) throws SAXException {}
 417                 @Override
 418                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 419                 @Override
 420                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 421                     throw saxparseexception;
 422                 }});
 423
 424             File file = new File(path);
 425             if (!file.canRead()) {
 426                 return new CustomTxtTraceDefinition[0];
 427             }
 428             Document doc = db.parse(file);
 429
 430             Element root = doc.getDocumentElement();
 431             if (! root.getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 432                 return new CustomTxtTraceDefinition[0];
 433             }
 434
 435             ArrayList<CustomTxtTraceDefinition> defList = new ArrayList<CustomTxtTraceDefinition>();
 436             NodeList nodeList = root.getChildNodes();
 437             for (int i = 0; i < nodeList.getLength(); i++) {
 438                 Node node = nodeList.item(i);
 439                 if (node instanceof Element && node.getNodeName().equals(DEFINITION_ELEMENT)) {
 440                     CustomTxtTraceDefinition def = extractDefinition((Element) node);
 441                     if (def != null) {
 442                         defList.add(def);
 443                     }
 444                 }
 445             }
 446             return defList.toArray(new CustomTxtTraceDefinition[0]);
 447         } catch (ParserConfigurationException e) {
 448             e.printStackTrace();
 449         } catch (SAXException e) {
 450             e.printStackTrace();
 451         } catch (IOException e) {
 452             e.printStackTrace();
 453         }
 454         return new CustomTxtTraceDefinition[0];
 455     }
 456
 457     public static CustomTxtTraceDefinition load(String definitionName) {
 458         try {
 459             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 460             DocumentBuilder db = dbf.newDocumentBuilder();
 461
 462             // The following allows xml parsing without access to the dtd
 463             EntityResolver resolver = new EntityResolver () {
 464                 @Override
 465                 public InputSource resolveEntity (String publicId, String systemId) {
 466                     String empty = "";
 467                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 468                     return new InputSource(bais);
 469                 }
 470             };
 471             db.setEntityResolver(resolver);
 472
 473             // The following catches xml parsing exceptions
 474             db.setErrorHandler(new ErrorHandler(){
 475                 @Override
 476                 public void error(SAXParseException saxparseexception) throws SAXException {}
 477                 @Override
 478                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 479                 @Override
 480                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 481                     throw saxparseexception;
 482                 }});
 483
 484             File file = new File(CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME);
 485             Document doc = db.parse(file);
 486
 487             Element root = doc.getDocumentElement();
 488             if (! root.getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 489                 return null;
 490             }
 491
 492             NodeList nodeList = root.getChildNodes();
 493             for (int i = 0; i < nodeList.getLength(); i++) {
 494                 Node node = nodeList.item(i);
 495                 if (node instanceof Element &&
 496                         node.getNodeName().equals(DEFINITION_ELEMENT) &&
 497                         definitionName.equals(((Element) node).getAttribute(NAME_ATTRIBUTE))) {
 498                     return extractDefinition((Element) node);
 499                 }
 500             }
 501         } catch (ParserConfigurationException e) {
 502             e.printStackTrace();
 503         } catch (SAXException e) {
 504             e.printStackTrace();
 505         } catch (IOException e) {
 506             e.printStackTrace();
 507         }
 508         return null;
 509     }
 510
 511     public static CustomTxtTraceDefinition extractDefinition(Element definitionElement) {
 512         CustomTxtTraceDefinition def = new CustomTxtTraceDefinition();
 513
 514         def.definitionName = definitionElement.getAttribute(NAME_ATTRIBUTE);
 515         if (def.definitionName == null) return null;
 516
 517         NodeList nodeList = definitionElement.getChildNodes();
 518         for (int i = 0; i < nodeList.getLength(); i++) {
 519             Node node = nodeList.item(i);
 520             String nodeName = node.getNodeName();
 521             if (nodeName.equals(TIME_STAMP_OUTPUT_FORMAT_ELEMENT)) {
 522                 Element formatElement = (Element) node;
 523                 def.timeStampOutputFormat = formatElement.getTextContent();
 524             } else if (nodeName.equals(INPUT_LINE_ELEMENT)) {
 525                 InputLine inputLine = extractInputLine((Element) node);
 526                 if (inputLine != null) {
 527                     def.inputs.add(inputLine);
 528                 }
 529             } else if (nodeName.equals(OUTPUT_COLUMN_ELEMENT)) {
 530                 Element outputColumnElement = (Element) node;
 531                 OutputColumn outputColumn = new OutputColumn();
 532                 outputColumn.name = outputColumnElement.getAttribute(NAME_ATTRIBUTE);
 533                 def.outputs.add(outputColumn);
 534             }
 535         }
 536         return def;
 537     }
 538
 539     private static InputLine extractInputLine(Element inputLineElement) {
 540         InputLine inputLine = new InputLine();
 541         NodeList nodeList = inputLineElement.getChildNodes();
 542         for (int i = 0; i < nodeList.getLength(); i++) {
 543             Node node = nodeList.item(i);
 544             String nodeName = node.getNodeName();
 545             if (nodeName.equals(CARDINALITY_ELEMENT)) {
 546                 Element cardinalityElement = (Element) node;
 547                 try {
 548                     int min = Integer.parseInt(cardinalityElement.getAttribute(MIN_ATTRIBUTE));
 549                     int max = Integer.parseInt(cardinalityElement.getAttribute(MAX_ATTRIBUTE));
 550                     inputLine.cardinality = new Cardinality(min, max);
 551                 } catch (NumberFormatException e) {
 552                     return null;
 553                 }
 554             } else if (nodeName.equals(REGEX_ELEMENT)) {
 555                 Element regexElement = (Element) node;
 556                 inputLine.regex = regexElement.getTextContent();
 557             } else if (nodeName.equals(INPUT_DATA_ELEMENT)) {
 558                 Element inputDataElement = (Element) node;
 559                 InputData inputData = new InputData();
 560                 inputData.name = inputDataElement.getAttribute(NAME_ATTRIBUTE);
 561                 inputData.action = Integer.parseInt(inputDataElement.getAttribute(ACTION_ATTRIBUTE));
 562                 inputData.format = inputDataElement.getAttribute(FORMAT_ATTRIBUTE);
 563                 inputLine.addColumn(inputData);
 564             } else if (nodeName.equals(INPUT_LINE_ELEMENT)) {
 565                 Element childInputLineElement = (Element) node;
 566                 InputLine childInputLine = extractInputLine(childInputLineElement);
 567                 if (childInputLine != null) {
 568                     inputLine.addChild(childInputLine);
 569                 }
 570             }
 571         }
 572         return inputLine;
 573     }
 574
 575     public static void delete(String definitionName) {
 576         try {
 577             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 578             DocumentBuilder db = dbf.newDocumentBuilder();
 579
 580             // The following allows xml parsing without access to the dtd
 581             EntityResolver resolver = new EntityResolver () {
 582                 @Override
 583                 public InputSource resolveEntity (String publicId, String systemId) {
 584                     String empty = "";
 585                     ByteArrayInputStream bais = new ByteArrayInputStream(empty.getBytes());
 586                     return new InputSource(bais);
 587                 }
 588             };
 589             db.setEntityResolver(resolver);
 590
 591             // The following catches xml parsing exceptions
 592             db.setErrorHandler(new ErrorHandler(){
 593                 @Override
 594                 public void error(SAXParseException saxparseexception) throws SAXException {}
 595                 @Override
 596                 public void warning(SAXParseException saxparseexception) throws SAXException {}
 597                 @Override
 598                 public void fatalError(SAXParseException saxparseexception) throws SAXException {
 599                     throw saxparseexception;
 600                 }});
 601
 602             File file = new File(CUSTOM_TXT_TRACE_DEFINITIONS_PATH_NAME);
 603             Document doc = db.parse(file);
 604
 605             Element root = doc.getDocumentElement();
 606             if (! root.getNodeName().equals(CUSTOM_TXT_TRACE_DEFINITION_ROOT_ELEMENT)) {
 607                 return;
 608             }
 609
 610             NodeList nodeList = root.getChildNodes();
 611             for (int i = 0; i < nodeList.getLength(); i++) {
 612                 Node node = nodeList.item(i);
 613                 if (node instanceof Element &&
 614                         node.getNodeName().equals(DEFINITION_ELEMENT) &&
 615                         definitionName.equals(((Element) node).getAttribute(NAME_ATTRIBUTE))) {
 616                     root.removeChild(node);
 617                 }
 618             }
 619
 620             Transformer transformer = TransformerFactory.newInstance().newTransformer();
 621             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 622
 623             //initialize StreamResult with File object to save to file
 624             StreamResult result = new StreamResult(new StringWriter());
 625             DOMSource source = new DOMSource(doc);
 626             transformer.transform(source, result);
 627             String xmlString = result.getWriter().toString();
 628
 629             FileWriter writer = new FileWriter(file);
 630             writer.write(xmlString);
 631             writer.close();
 632         } catch (ParserConfigurationException e) {
 633             e.printStackTrace();
 634         } catch (SAXException e) {
 635             e.printStackTrace();
 636         } catch (IOException e) {
 637             e.printStackTrace();
 638         } catch (TransformerConfigurationException e) {
 639             e.printStackTrace();
 640         } catch (TransformerFactoryConfigurationError e) {
 641             e.printStackTrace();
 642         } catch (TransformerException e) {
 643             e.printStackTrace();
 644         }
 645     }
 646 }