View Javadoc

1   package com.google.code.jetm.reporting.xml;
2   
3   import java.io.IOException;
4   import java.io.Reader;
5   import java.io.Writer;
6   import java.util.Collection;
7   import java.util.LinkedList;
8   import java.util.List;
9   
10  import org.jdom.CDATA;
11  import org.jdom.Document;
12  import org.jdom.Element;
13  import org.jdom.JDOMException;
14  import org.jdom.Namespace;
15  import org.jdom.input.SAXBuilder;
16  import org.jdom.output.XMLOutputter;
17  
18  import com.google.code.jetm.reporting.AggregateBinder;
19  
20  import etm.core.aggregation.Aggregate;
21  
22  /**
23   * A binder to bind an {@link Aggregate} object to XML and back again.
24   * 
25   * @author jrh3k5
26   * 
27   */
28  
29  public class XmlAggregateBinder implements AggregateBinder {
30      private final Namespace jetmNamespace = Namespace
31              .getNamespace("http://code.google.com/p/jetm-reporting-utilities/jetm-measurement");
32  
33      /**
34       * {@inheritDoc}
35       */
36      public void bind(Collection<? extends Aggregate> aggregates, Writer writer) {
37          final Element rootElement = new Element("measurements", jetmNamespace);
38          for (Aggregate aggregate : aggregates)
39              rootElement.addContent(toElement(aggregate));
40  
41          try {
42              new XMLOutputter().output(rootElement, writer);
43          } catch (IOException e) {
44              throw new RuntimeException("Failed to write aggregate data to XML.", e);
45          }
46      }
47  
48      /**
49       * {@inheritDoc}
50       */
51      @SuppressWarnings("unchecked")
52      public Collection<Aggregate> unbind(Reader reader) {
53          Document document;
54          try {
55              document = new SAXBuilder().build(reader);
56          } catch (JDOMException e) {
57              throw new RuntimeException("Failed to read XML data from reader.", e);
58          } catch (IOException e) {
59              throw new RuntimeException("Failed to read XML data from reader.", e);
60          }
61          final List<Aggregate> aggregates = new LinkedList<Aggregate>();
62          for (Element element : (List<Element>) document.getRootElement().getChildren("measurement",
63                  jetmNamespace))
64              aggregates.add(fromElement(element));
65          return aggregates;
66      }
67  
68      /**
69       * Turn a {@code <measurement />} XML element into an aggregate.
70       * 
71       * @param element
72       *            An {@link Element} representing the XML to be converted.
73       * @return An {@link Aggregate} built out of the given XML.
74       */
75      private Aggregate fromElement(Element element) {
76          final String measurementName = element.getChildText("measurementName", jetmNamespace);
77          final double min = Double.parseDouble(element.getChildText("min", jetmNamespace));
78          final double max = Double.parseDouble(element.getChildText("max", jetmNamespace));
79          final double total = Double.parseDouble(element.getChildText("total", jetmNamespace));
80          final long measurements = Long.parseLong(element
81                  .getChildText("measurements", jetmNamespace));
82  
83          return new XmlAggregate(min, max, total, measurements, measurementName);
84      }
85  
86      /**
87       * Convert an aggregate to an XML element.
88       * 
89       * @param aggregate
90       *            The {@link Aggregate} to be converted into XML.
91       * @return An {@link Element} representing the XML built out of the given
92       *         aggregate.
93       */
94      private Element toElement(Aggregate aggregate) {
95          final Element element = new Element("measurement", jetmNamespace);
96  
97          final Element nameElement = new Element("measurementName", jetmNamespace);
98          nameElement.setContent(new CDATA(aggregate.getName()));
99          element.addContent(nameElement);
100 
101         final Element minElement = new Element("min", jetmNamespace);
102         minElement.setText(Double.toString(aggregate.getMin()));
103         element.addContent(minElement);
104 
105         final Element maxElement = new Element("max", jetmNamespace);
106         maxElement.setText(Double.toString(aggregate.getMax()));
107         element.addContent(maxElement);
108 
109         final Element totalElement = new Element("total", jetmNamespace);
110         totalElement.setText(Double.toString(aggregate.getTotal()));
111         element.addContent(totalElement);
112 
113         final Element measurementsElement = new Element("measurements", jetmNamespace);
114         measurementsElement.setText(Long.toString(aggregate.getMeasurements()));
115         element.addContent(measurementsElement);
116 
117         return element;
118     }
119 }