1 /*

     2 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 package com.nokia.ant.listener.internaldata;

    19 

    20 import java.util.Iterator;

    21 import java.util.Vector;

    22 import java.util.Hashtable;

    23 import java.util.Enumeration;

    24 import java.io.ByteArrayOutputStream;

    25 

    26 import org.dom4j.Document;

    27 //import org.dom4j.DefaultDocumentType;

    28 import org.dom4j.DocumentHelper;

    29 import org.dom4j.Element;

    30 import org.dom4j.io.XMLWriter;

    31 import org.dom4j.io.OutputFormat;

    32 

    33 import org.apache.tools.ant.BuildEvent;

    34 /**

    35  * This xml render object does the following - 

    36  * Generates target only for TargetNode type of node

    37  * Creates the targets section.

    38  * Generates task only for TargetNode type of node

    39  * Creates the task section.

    40  * Creates execution tree recursively, visiting the DataNodes.

    41  * Creates the execution tree section.

    42  * Creates the property section.

    43  * Renders the build node into XML string. 

    44  */

    45 public class XMLRenderer {

    46 

    47     // Dump of properties

    48     private Hashtable<String, String> properties;

    49     // the toplevel node.

    50     private BuildNode root;

    51     private BuildEvent buildEvent;

    52     

    53     // Helium content database. 

    54     private Document database;

    55     

    56     // Deps hashes: helper to remove duplicates.

    57     private Vector<String> targetList = new Vector<String>();

    58     private Vector<String> taskList = new Vector<String>();

    59     private Vector<String> assertList = new Vector<String>();

    60     

    61     public XMLRenderer(BuildNode root, Document database, Hashtable<String, String> properties, BuildEvent event) {

    62         this.root = root; 

    63         this.database = database;

    64         this.properties = properties;

    65         this.buildEvent = event;

    66     }

    67 

    68     /**

    69      * Generating target only for TargetNode type of node

    70      * @param node

    71      * @param targets

    72      */

    73     protected void createTarget(DataNode node, Element targets) {

    74         if (node instanceof TargetNode) {

    75             TargetNode targetNode = (TargetNode)node;            

    76             if (!targetList.contains(targetNode.getName() + targetNode.getFilename())) {

    77                 targetList.add(targetNode.getName() + targetNode.getFilename());

    78                 Element target = targets.addElement("target");

    79                 target.addAttribute("id", "target@" + targetList.indexOf(targetNode.getName() + targetNode.getFilename()));

    80                 target.addAttribute("name", targetNode.getName());

    81                 target.addAttribute("file", targetNode.getFilename());

    82                 target.addAttribute("line", "" + targetNode.getLine());

    83             }

    84         }

    85         for (Iterator<DataNode> i = node.iterator() ; i.hasNext() ; ) {

    86             createTarget(i.next(), targets);

    87         }

    88     }

    89 

    90     /**

    91      * Creating the targets section.

    92      * @param statistics

    93      */

    94     protected void createTargets(Element statistics) {

    95         Element targets = statistics.addElement("targets");

    96         if (root != null) {

    97             createTarget(root, targets);

    98         }

    99     }

   100 

   101     /**

   102      * Generating task only for TargetNode type of node

   103      * @param node

   104      * @param targets

   105      */

   106     protected void createTask(DataNode node, Element targets) {

   107         if (node instanceof TaskNode) {            

   108             TaskNode taskNode = (TaskNode)node;

   109             if (!taskList.contains(taskNode.getName())) {

   110                 taskList.add(taskNode.getName());

   111                 Element target = targets.addElement("task");

   112                 target.addAttribute("id", "task@" + taskList.indexOf(taskNode.getName()));

   113                 target.addAttribute("name", taskNode.getName());                

   114             }

   115         }

   116         for (Iterator<DataNode> i = node.iterator() ; i.hasNext() ; ) {

   117             createTask(i.next(), targets);

   118         }

   119     }    

   120     

   121     /**

   122      * Creating the task section.

   123      * @param statistics

   124      */

   125     protected void createTasks(Element statistics) {

   126         Element tasks = statistics.addElement("tasks");

   127         if (root != null) {

   128             createTask(root, tasks);

   129         }

   130     }

   131     

   132     /**

   133      * Creating the assert section.

   134      * @param statistics

   135      */

   136     protected void createAsserts(Element statistics) {

   137         Element asserts = statistics.addElement("asserts");

   138         if (root != null) {

   139             createAssert(root, asserts);

   140         }

   141     }

   142     

   143     /**

   144      * Generating assert only for TargetNode type of node

   145      * @param node

   146      * @param targets

   147      */

   148     protected void createAssert(DataNode node, Element targets) {

   149         

   150         if (node instanceof AssertNode) {

   151             AssertNode assertNode = (AssertNode)node;

   152             if (assertNode.getAssertName() != null) {

   153                 assertList.add(assertNode.getAssertName());

   154                 Element target = targets.addElement("assert");

   155                 target.addAttribute("id", "assert@" + assertList.indexOf(assertNode.getAssertName()));

   156                 target.addAttribute("name", assertNode.getAssertName());

   157                 //target.addAttribute("assertname", assertNode.getAssertName());

   158                 target.addAttribute("file", assertNode.getFilename());

   159                 target.addAttribute("line", "" + assertNode.getLine());

   160                 target.addAttribute("message", "" + assertNode.getMessage());

   161             }

   162             

   163         }

   164         for (Iterator<DataNode> i = node.iterator() ; i.hasNext() ; ) {

   165             createAssert(i.next(), targets);

   166         }

   167     }

   168 

   169     /**

   170      * Creating execution tree recursively, visiting the DataNodes.

   171      * @param node

   172      * @param tree

   173      */

   174     protected void createTree(DataNode node, Element tree) {

   175         Element elt = null;

   176         if (node instanceof BuildNode) {

   177             BuildNode buildNode = (BuildNode)node;

   178             elt = tree.addElement("build");

   179             elt.addAttribute("name", buildNode.getName());            

   180             elt.addAttribute("startTime", "" + buildNode.getStartTime().getTime());

   181             elt.addAttribute("endTime", "" + buildNode.getEndTime().getTime());

   182             elt.addAttribute("status", buildNode.getSuccessful() ? "successful" : "failed");            

   183             elt.addAttribute("thread", "" + buildNode.getThreadId());            

   184         } else if (node instanceof TargetNode) {

   185             TargetNode targetNode = (TargetNode)node;

   186             elt = tree.addElement("targetRef");

   187             elt.addAttribute("reference", "target@" + targetList.indexOf(targetNode.getName() + targetNode.getFilename()));

   188             elt.addAttribute("startTime", "" + targetNode.getStartTime().getTime());

   189             elt.addAttribute("endTime", "" + targetNode.getEndTime().getTime());

   190             elt.addAttribute("thread", "" + targetNode.getThreadId());

   191             elt.addAttribute("startUsedHeap", "" + targetNode.getStartUsedHeap());

   192             elt.addAttribute("startCommittedHeap", "" + targetNode.getStartCommittedHeap());

   193             elt.addAttribute("endUsedHeap", "" + targetNode.getEndUsedHeap());

   194             elt.addAttribute("endCommittedHeap", "" + targetNode.getEndCommittedHeap());

   195         } else if (node instanceof TaskNode) {

   196             TaskNode taskNode = (TaskNode)node;

   197             elt = tree.addElement("taskRef");

   198             elt.addAttribute("reference", "task@" + taskList.indexOf(taskNode.getName()));

   199             elt.addAttribute("startTime", "" + taskNode.getStartTime().getTime());

   200             elt.addAttribute("endTime", "" + taskNode.getEndTime().getTime());

   201             elt.addAttribute("thread", "" + taskNode.getThreadId());

   202         } else if (node instanceof AssertNode) {

   203             AssertNode assertNode = (AssertNode)node;

   204             if (assertNode.getAssertName() != null) {

   205                 elt = tree.addElement("assertRef");

   206                 elt.addAttribute("reference", "assert@" + assertList.indexOf(assertNode.getAssertName()));

   207                 elt.addAttribute("startTime", "" + assertNode.getStartTime().getTime());

   208                 elt.addAttribute("endTime", "" + assertNode.getEndTime().getTime());

   209                 elt.addAttribute("thread", "" + assertNode.getThreadId());

   210             }

   211         }

   212         

   213         if (elt != null) {

   214             for (Iterator<DataNode> i = node.iterator() ; i.hasNext() ; ) {

   215                 createTree(i.next(), elt);

   216             }

   217         }

   218     }

   219     

   220     /**

   221      * Creating the execution tree section.

   222      * @param statistics

   223      */

   224     protected void createExecutionTree(Element statistics) {

   225         Element executionTree = statistics.addElement("executionTree");

   226         if (root != null) {

   227             createTree(root, executionTree);

   228         }

   229     }

   230 

   231     /**

   232      * Creating the property section.

   233      * @param statistics

   234      */

   235     protected void createProperties(Element statistics) {

   236         Element propertiesElt = statistics.addElement("properties");

   237         if (properties != null) {

   238             for (Enumeration<String> e = properties.keys(); e.hasMoreElements() ; ) {

   239                 String key = e.nextElement();

   240                 Element propertyElt = propertiesElt.addElement("property");

   241                 propertyElt.addAttribute("name", key);

   242                 propertyElt.addAttribute("value", properties.get(key));

   243             }

   244         }

   245     }

   246     

   247     protected void insertDatabase(Element statistics) {

   248         if (database != null) {

   249             Element databaseElt = statistics.addElement("database");

   250             databaseElt.add(database.getRootElement().detach());

   251         }

   252     }

   253     

   254     /**

   255      * Rendering the build node into XML string. 

   256      */

   257     public String toString() {

   258         // Creating the XML document

   259         Document document = DocumentHelper.createDocument();

   260         // DefaultDocumentType(String elementName, String publicID, String systemID) 

   261         //document.setDocType(new DefaultDocumentType());

   262         Element statistics = document.addElement( "statistics" );

   263         statistics.addAttribute("version", "1.0");

   264         

   265         // Creating the document content.

   266         insertDatabase(statistics);

   267         createTargets(statistics);

   268         createTasks(statistics);

   269         createAsserts(statistics);

   270         createExecutionTree(statistics);

   271         createProperties(statistics);

   272         try {

   273             ByteArrayOutputStream output = new ByteArrayOutputStream(); 

   274             XMLWriter out = new XMLWriter(output, OutputFormat.createPrettyPrint());

   275             out.write(document);

   276             return output.toString();

   277         } catch (Exception exc) {

   278             return document.asXML();            

   279         }        

   280     }

   281     

   282 }