SimpleSlice.java

Violations

Source code

/*
  * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
  */
package biz.hammurapi.metrics;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.w3c.dom.Element;

import biz.hammurapi.xml.dom.DomSerializable;

/**
 * @author Pavel Vlasov
 *
 * @version $Revision: 1.4 $
 */
public class SimpleSlice implements Slice, Serializable, DomSerializable {

	/**
	 * Comment for <code>serialVersionUID</code>
	 */
	private static final long serialVersionUID = 6148347920575353798L;

	private String name;
	private boolean keepMeasurements;
    private int measurements;
    private double total;
    private double min;
    private double max;
    private double deviation;
    private List measurementsList;
	private long from;
	private long to;

	public SimpleSlice(String name) {
		this(name, false);
	}
	
	public SimpleSlice(String name, boolean keepMeasurements) {
		this.name=name;
		this.keepMeasurements=keepMeasurements;
		measurementsList=new ArrayList();
	}	
	
	/**
	 * Constructs a copy of master slice.
	 * @param master
	 */
	public SimpleSlice(Slice master) {
		name = master.getName();
	    measurements = master.getNumber();
	    total = master.getTotal();
	    min = master.getMin();
	    max = master.getMax();
	    deviation = master.getDeviation();
		from = master.getFrom();
		to = master.getTo();		

		if (master.getMeasurements()!=null && !master.getMeasurements().isEmpty()) {
			keepMeasurements = true;
			measurementsList = new ArrayList();
			Iterator it = master.getMeasurements().iterator();
			while (it.hasNext()) {
				measurementsList.add(new SimpleMeasurement((Measurement) it.next()));
			}
		}
	}
    
    public int getNumber() {
        return measurements;
    }
    
    public double getMin() {
        return min;
    }
    
    public double getMax() {
        return max;
    }
    
    public double getAvg() {
        return total/measurements;
    }
    
    public double getTotal() {
        return total;
    }
    
    public void add(final double value, final long time) {
        if (measurements==0 || value<min) {
            min=value;
        }
        
        if (measurements==0 || value>max) {
            max=value;
        }
        
        if (measurements==0 || from>time) {
        	from=time;
        }
        
        if (measurements==0 || to<time) {
        	to=time;
        }
        
        total+=value;        
        measurements++;
        deviation+=Math.abs(value-total/measurements);
       
        if (keepMeasurements) {
        	class PrivateMeasurement implements Measurement, Serializable {
				public double getValue() {
					return value;
				}

				public long getTime() {
					return time;
				}        	        		
        	}
        	
			measurementsList.add(new PrivateMeasurement());
        }
    }
    
    public void add(Metric metric) {
        if (measurements==0 || metric.getMin()<min) {
            min=metric.getMin();
        }
        
        if (measurements==0 || metric.getMax()>max) {
            max=metric.getMax();
        }
        
        if (metric instanceof Slice) {
        	Slice slice=(Slice) metric;
	        if (measurements==0 || from>slice.getFrom()) {
	        	from=slice.getFrom();
	        }
	        
	        if (measurements==0 || to<slice.getTo()) {
	        	to=slice.getTo();
	        }
        }
        
        measurements+=metric.getNumber();
        total+=metric.getTotal();
        deviation+=metric.getDeviation()*metric.getNumber();
        
        if (keepMeasurements) {
        	measurementsList.addAll(metric.getMeasurements());
        }
    }
    
	public Collection getMeasurements() {
		return measurementsList;
	}

	public String getName() {
		return name;
	}    
	
	public String toString() {
		StringBuffer ret=new StringBuffer();
		ret.append(measurements)
			.append("/")
			.append(total)
			.append(" <= ")
			.append(name)
			.append("\n");
		if (measurementsList!=null) {
			Iterator it=measurementsList.iterator();
			while (it.hasNext()) {
				Measurement m=(Measurement) it.next();
				ret.append("\t");
				ret.append(m.getValue());
				ret.append(" <- ");
				ret.append(new Date(m.getTime()));
				ret.append("\n");
			}
		}
		return ret.toString();
	}

	public int compareTo(Object o) {
		if (o instanceof Slice) {
			return Double.compare(((Slice) o).getTotal(), total);  
		}
		
		return 1;
	}
	
	public long getFrom() {
		return from;
	}

	public long getTo() {
		return to;
	}

    public double getDeviation() {
        return deviation/measurements;
    }

	public void toDom(Element holder) {
		holder.setAttribute("name", getName());
        holder.setAttribute("avg", String.valueOf(getAvg()));
       	holder.setAttribute("min", String.valueOf(getMin()));
		holder.setAttribute("max", String.valueOf(getMax()));
		
        holder.setAttribute("total", String.valueOf(getTotal()));
        holder.setAttribute("number", String.valueOf(getNumber()));
		holder.setAttribute("deviation", String.valueOf(getDeviation()));
       
        Collection measurements = getMeasurements();
		if (measurements!=null) {
	        Iterator it=measurements.iterator();
	        while (it.hasNext()) {
	        	Measurement ms=(Measurement) it.next();
	        	Element me = holder.getOwnerDocument().createElement("measurement");
				holder.appendChild(me);
				me.setAttribute("value", String.valueOf(ms.getValue()));
				me.setAttribute("time", String.valueOf(ms.getTime()));
	        }
        }
	}
}