/**

  * Copyright (c) 2012, University of Konstanz, Distributed Systems Group

  * All rights reserved.

  * 

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions are met:

  * * Redistributions of source code must retain the above copyright

  * notice, this list of conditions and the following disclaimer.

  * * Redistributions in binary form must reproduce the above copyright

  * notice, this list of conditions and the following disclaimer in the

  * documentation and/or other materials provided with the distribution.

  * * Neither the name of the University of Konstanz nor the

  * names of its contributors may be used to endorse or promote products

  * derived from this software without specific prior written permission.

  * 

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  */

 package org.perfidix.result;

 import java.util.Collection;

 import java.util.Hashtable;

 import java.util.LinkedList;

 import java.util.Map;

 import java.util.Set;

 import org.apache.commons.collections.primitives.adapters.CollectionDoubleCollection;

 import org.apache.commons.math.stat.descriptive.AbstractUnivariateStatistic;

 import org.apache.commons.math.stat.descriptive.moment.Mean;

 import org.apache.commons.math.stat.descriptive.moment.StandardDeviation;

 import org.apache.commons.math.stat.descriptive.rank.Max;

 import org.apache.commons.math.stat.descriptive.rank.Min;

 import org.apache.commons.math.stat.descriptive.rank.Percentile;

 import org.apache.commons.math.stat.descriptive.summary.Sum;

 import org.apache.commons.math.stat.descriptive.summary.SumOfSquares;

 import org.perfidix.meter.AbstractMeter;

 /**

  * Results which are generated through the benchmark are stored in the inherted

  * implementation of this class. The storage is done corresponding to the

  * mapping of meters.

  * 

  * @author Sebastian Graf, University of Konstanz

  * @author Alexander Onea, neue Couch

  */

 public abstract class AbstractResult {

     /** Related element of this container. Can be a method or a class. */

     private transient final Object relatedElement;

     /**

      * Results mapped to the meters.

      */

     private transient final Map<AbstractMeter, Collection<Double>> meterResults;

     /**

      * Constructor with a given name.

      * 

      * @param paramElement

      *            element to this result.

      */

     protected AbstractResult(final Object paramElement) {

         this.relatedElement = paramElement;

         this.meterResults = new Hashtable<AbstractMeter, Collection<Double>>();

     }

     /**

      * Returns the name of the related element where these results belong to.

      * 

      * @return the name as a String.

      */

     public abstract String getElementName();

     /**

      * an array of all data items in the structure.

      * 

      * @param meter

      *            for the results wanted

      * @return the result set.

      */

     public final Collection<Double> getResultSet(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         return this.meterResults.get(meter);

     }

     /**

      * Getting all meters registered in this result.

      * 

      * @return a set of all meters.

      */

     public final Set<AbstractMeter> getRegisteredMeters() {

         return this.meterResults.keySet();

     }

     /**

      * Returns the arithmetic mean of the result set. avg() is an alias for this

      * method.

      * 

      * @param meter

      *            the meter of the mean

      * @return the mean value.

      */

     public final double mean(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic mean = new Mean();

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return mean.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Computes the square sum of the elements.

      * 

      * @param meter

      *            the meter of the mean

      * @return the square sum.

      */

     public final double squareSum(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic sqrSum = new SumOfSquares();

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return sqrSum.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Computes the standard deviation.

      * 

      * @param meter

      *            the meter of the mean

      * @return the standard deviation

      */

     public final double getStandardDeviation(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic stdDev = new StandardDeviation();

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return stdDev.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Computes the sum over all data items.

      * 

      * @param meter

      *            the meter of the mean

      * @return the sum of all runs.

      */

     public final double sum(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic sum = new Sum();

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return sum.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Computes the minimum.

      * 

      * @param meter

      *            the meter of the mean

      * @return the minimum result value.

      */

     public final double min(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic min = new Min();

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return min.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Computes the confidence 05 interval-factor. This value has to be combined

      * with the mean to get the confidence-interval.

      * 

      * @param meter

      *            the meter for the 05-confidence interval factor

      * @return the 99% confidence

      */

     public final double getConf05(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic conf05 = new Percentile(5.0);

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return conf05.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Computes the confidence 95 interval-factor. This value has to be combined

      * with the mean to get the confidence-interval.

      * 

      * @param meter

      *            the meter for the 95-confidence interval factor

      * @return the 95% confidence

      */

     public final double getConf95(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic conf95 = new Percentile(95.0);

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return conf95.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Computes the maximum.

      * 

      * @param meter

      *            the meter of the mean

      * @return the maximum result value.

      */

     public final double max(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         final AbstractUnivariateStatistic max = new Max();

         final CollectionDoubleCollection doubleColl =

             new CollectionDoubleCollection(this.meterResults.get(meter));

         return max.evaluate(doubleColl.toArray(), 0, doubleColl.toArray().length);

     }

     /**

      * Returning the number of results for one specific meter.

      * 

      * @param meter

      *            to get the number of results

      * @return the number of results of one meter

      */

     public final int getNumberOfResult(final AbstractMeter meter) {

         checkIfMeterExists(meter);

         return meterResults.get(meter).size();

     }

     /**

      * Getter for the related element where this container corresponds to.

      * 

      * @return the relatedElement

      */

     public final Object getRelatedElement() {

         return relatedElement;

     }

     /**

      * Adding a data to a meter.

      * 

      * @param meter

      *            the related meter

      * @param data

      *            the data to be added

      */

     protected final void addData(final AbstractMeter meter, final double data) {

         checkIfMeterExists(meter);

         meterResults.get(meter).add(data);

     }

     /**

      * Checking method if meter is registered, otherwise inserting a suitable

      * data structure.

      * 

      * @param meter

      *            to be checked

      */

     private void checkIfMeterExists(final AbstractMeter meter) {

         if (!meterResults.containsKey(meter)) {

             meterResults.put(meter, new LinkedList<Double>());

         }

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public String toString() {

         final StringBuilder builder = new StringBuilder();

         builder.append(getElementName()).append("\nmeters: ").append(getRegisteredMeters()).append(

             "\nresults: ").append(meterResults);

         return builder.toString();

     }

 }