Coverage Report - com.google.code.jetm.reporting.xml.XmlAggregateBinder
 
Classes in this File Line Coverage Branch Coverage Complexity
XmlAggregateBinder
86%
37/43
100%
4/4
3
 
 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  1
 public class XmlAggregateBinder implements AggregateBinder {
 30  1
     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  1
         final Element rootElement = new Element("measurements", jetmNamespace);
 38  1
         for (Aggregate aggregate : aggregates)
 39  1
             rootElement.addContent(toElement(aggregate));
 40  
 
 41  
         try {
 42  1
             new XMLOutputter().output(rootElement, writer);
 43  0
         } catch (IOException e) {
 44  0
             throw new RuntimeException("Failed to write aggregate data to XML.", e);
 45  1
         }
 46  1
     }
 47  
 
 48  
     /**
 49  
      * {@inheritDoc}
 50  
      */
 51  
     @SuppressWarnings("unchecked")
 52  
     public Collection<Aggregate> unbind(Reader reader) {
 53  
         Document document;
 54  
         try {
 55  1
             document = new SAXBuilder().build(reader);
 56  0
         } catch (JDOMException e) {
 57  0
             throw new RuntimeException("Failed to read XML data from reader.", e);
 58  0
         } catch (IOException e) {
 59  0
             throw new RuntimeException("Failed to read XML data from reader.", e);
 60  1
         }
 61  1
         final List<Aggregate> aggregates = new LinkedList<Aggregate>();
 62  1
         for (Element element : (List<Element>) document.getRootElement().getChildren("measurement",
 63  
                 jetmNamespace))
 64  1
             aggregates.add(fromElement(element));
 65  1
         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  1
         final String measurementName = element.getChildText("measurementName", jetmNamespace);
 77  1
         final double min = Double.parseDouble(element.getChildText("min", jetmNamespace));
 78  1
         final double max = Double.parseDouble(element.getChildText("max", jetmNamespace));
 79  1
         final double total = Double.parseDouble(element.getChildText("total", jetmNamespace));
 80  1
         final long measurements = Long.parseLong(element
 81  
                 .getChildText("measurements", jetmNamespace));
 82  
 
 83  1
         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  1
         final Element element = new Element("measurement", jetmNamespace);
 96  
 
 97  1
         final Element nameElement = new Element("measurementName", jetmNamespace);
 98  1
         nameElement.setContent(new CDATA(aggregate.getName()));
 99  1
         element.addContent(nameElement);
 100  
 
 101  1
         final Element minElement = new Element("min", jetmNamespace);
 102  1
         minElement.setText(Double.toString(aggregate.getMin()));
 103  1
         element.addContent(minElement);
 104  
 
 105  1
         final Element maxElement = new Element("max", jetmNamespace);
 106  1
         maxElement.setText(Double.toString(aggregate.getMax()));
 107  1
         element.addContent(maxElement);
 108  
 
 109  1
         final Element totalElement = new Element("total", jetmNamespace);
 110  1
         totalElement.setText(Double.toString(aggregate.getTotal()));
 111  1
         element.addContent(totalElement);
 112  
 
 113  1
         final Element measurementsElement = new Element("measurements", jetmNamespace);
 114  1
         measurementsElement.setText(Long.toString(aggregate.getMeasurements()));
 115  1
         element.addContent(measurementsElement);
 116  
 
 117  1
         return element;
 118  
     }
 119  
 }