domain/pools/Statistic.java

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.math.BigInteger;
import java.util.Date;
import java.util.Iterator;
import java.text.*;

import com.sun.solaris.service.pools.UnsignedInt64;

/**
 * Contains the information relating to a specific statistic for an
 * object. The Statistic has no notion of the source of the data, it
 * is simply a repository for holding statistical information.
 */
interface Statistic
{
	/**
	 * Return the start of the sample period for which the
	 * statistic is representative.
	 */
	public Date getStart();

	/**
	 * Return the end of the sample period for which the
	 * statistic is representative.
	 */
	public Date getEnd();

	/**
	 * Get the value of this statistic.
	 */
	public Object getValue();

	/**
	 * Get the value of this statistic as a Long.
	 */
	public Long getLongValue();

	/**
	 * Get the value of this statistic as a Double.
	 */
	public Double getDoubleValue();

	/**
	 * Get the value of this statistic as a UnsignedInt64.
	 */
	public UnsignedInt64 getUnsignedInt64Value();
}

/**
 * An interface for Statistics which may be aggregated.
 */
interface AggregateStatistic extends Statistic
{
	/**
	 * Add the supplied statistic to this.
	 *
	 * @param o The other statistic.
	 */
	public AggregateStatistic add(AggregateStatistic o);

	/**
	 * Subtract the supplied statistic from this.
	 *
	 * @param o The other statistic.
	 */
	public AggregateStatistic subtract(AggregateStatistic o);

	/**
	 * Produce the aggregate of all objects in the supplied
	 * iterator (which must be of the same type) whose start and
	 * end dates lie within the supplied ranges. If either start
	 * or end is null, then that bound is not applied. i.e. if no
	 * start date is supplied, then start checking is disabled.
	 *
	 * @param start The start date for qualification in the snapshot.
	 * @param end The end date for qualification in the snapshot.
	 * @throws IllegalArgumentException If the iterator is empty.
	 */
	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException;
}

/**
 * A basic Statistic implementation which makes it easy to derive
 * concrete statistic types. This is an immutable class, the state is
 * set when the object is constructed and cannot be later changed.
 */
abstract class AbstractStatistic implements Statistic
{
	/**
	 * The value of the statistic.
	 */
	private final Object value;

	/**
	 * The start of the interval during which the statistic was
	 * captured.
	 */
	private final Date start;

	/**
	 * The end of the interval during which the statistic was
	 * captured.
	 */
	private final Date end;

	/**
	 * Formatter for the sample start time, used by toString().
	 */
	private static final DateFormat df = new SimpleDateFormat("kk:mm:ss");

	/**
	 * Constructor. This is provided as a mechanism to allow
	 * inherited classes to correctly initialize their state.
	 *
	 * @param value The value of this statistic.
	 */
	protected AbstractStatistic(Object value)
	{
		this(value, null, null);
	}

	/**
	 * Constructor. This is provided as a mechanism to allow
	 * inherited classes to correctly initialize their state.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the sample period which this
	 * statistic represents.
	 * @param end The end of the sample period which this
	 * statistic represents.
	 */
	protected AbstractStatistic(Object value, Date start, Date end)
	{
		this.value = value;
		this.start = start;
		this.end = end;
	}

	/**
	 * Return the start of the sample period for which the
	 * statistic is representative.
	 */
	public Date getStart()
	{
		return (start);
	}


	/**
	 * Return the end of the sample period for which the
	 * statistic is representative.
	 */
	public Date getEnd()
	{
		return (end);
	}

	/**
	 * Get the value of this statistic.
	 */
	public Object getValue()
	{
		return (value);
	}

	public abstract Long getLongValue();
	public abstract Double getDoubleValue();
	public abstract UnsignedInt64 getUnsignedInt64Value();

	/**
	 * Return the string representation of this statistic.
	 */
	public String toString()
	{
		StringBuffer buf = new StringBuffer();

		buf.append(value);
		if (start != null && end != null) {
			buf.append(" from ");
			buf.append(df.format(start));
			buf.append(" to ");
			buf.append(df.format(end));
		}
		return (buf.toString());
	}
}

/**
 * A statistic of type Double.
 */
final class DoubleStatistic extends AbstractStatistic
    implements AggregateStatistic
{

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 */
	public DoubleStatistic(Double value)
	{
		super(value);
	}

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the interval over which this
	 * statistic is representative.
	 * @param end The end of the interval over which this
	 * statistic is representative.
	 */
	public DoubleStatistic(Double value, Date start, Date end)
	{
		super(value, start, end);
	}

	public Double getDoubleValue()
	{
		return ((Double) getValue());
	}

	public Long getLongValue()
	{
		return (new Long(((Double) getValue()).longValue()));
	}

	public UnsignedInt64 getUnsignedInt64Value()
	{
		return (new UnsignedInt64(Long.toString(((Double) getValue()).
					      longValue())));
	}

	public AggregateStatistic add(AggregateStatistic o)
	{
		Double v1 = getDoubleValue();
		Double v2 = o.getDoubleValue();

		return (new DoubleStatistic(new Double(v1.doubleValue() +
					    v2.doubleValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic subtract(AggregateStatistic o)
	{
		Double v1 = getDoubleValue();
		Double v2 = o.getDoubleValue();

		return (new DoubleStatistic(new Double(v1.doubleValue() -
					    v2.doubleValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException
	{
		double total = 0;
		int count = 0;
		Date first = start, last = end;

		while (it.hasNext()) {
			DoubleStatistic s = (DoubleStatistic) it.next();
			if (start != null) {
				if (s.getStart().compareTo(start) < 0)
					continue;
			}
			if (first == null)
				first = s.getStart();
			if (end != null) {
				if (s.getEnd().compareTo(end) > 0)
					continue;
			}
			last = s.getEnd();
			total += s.getDoubleValue().doubleValue();
			count++;
		}
		if (count == 0)
			throw new IllegalArgumentException("Cannot derive a " +
			    "snapshot from an empty iterator");
		return (new DoubleStatistic(new Double(total / count), first,
			last));
	}
}

/**
 * A statistic of type Long.
 */
final class LongStatistic extends AbstractStatistic
    implements AggregateStatistic
{

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the interval over which this
	 * statistic is representative.
	 * @param end The end of the interval over which this
	 * statistic is representative.
	 */
	public LongStatistic(Long value, Date start, Date end)
	{
		super(value, start, end);
	}

	public Double getDoubleValue()
	{
		return (new Double(((Long) getValue()).longValue()));
	}

	public Long getLongValue()
	{
		return ((Long) getValue());
	}

	public UnsignedInt64 getUnsignedInt64Value()
	{
		return (new UnsignedInt64(Long.toString(((Long) getValue()).
					      longValue())));
	}

	public AggregateStatistic add(AggregateStatistic o)
	{
		Long v1 = getLongValue();
		Long v2 = o.getLongValue();

		return (new LongStatistic(new Long(v1.longValue() +
					    v2.longValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic subtract(AggregateStatistic o)
	{
		Long v1 = getLongValue();
		Long v2 = o.getLongValue();

		return (new LongStatistic(new Long(v1.longValue() -
					    v2.longValue()),
			getStart(), getEnd()));
	}

	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException
	{
		long total = 0;
		int count = 0;
		Date first = start, last = end;
		while (it.hasNext()) {
			LongStatistic s = (LongStatistic) it.next();
			if (start != null) {
				if (s.getStart().compareTo(start) < 0)
					continue;
			}
			if (first == null)
				first = s.getStart();
			if (end != null) {
				if (s.getEnd().compareTo(end) > 0)
					continue;
			}
			last = s.getEnd();
			total += s.getLongValue().longValue();
			count++;
		}
		if (count == 0)
			throw new IllegalArgumentException("Cannot derive a " +
			    "snapshot from an empty iterator");
		return (new LongStatistic(new Long(total / count), first,
			last));
	}
}

/**
 * A statistic of type UnsignedInt64.
 */
final class UnsignedInt64Statistic extends AbstractStatistic
    implements AggregateStatistic
{

	/**
	 * Constructor.
	 *
	 * @param value The value of this statistic.
	 * @param start The start of the interval over which this
	 * statistic is representative.
	 * @param end The end of the interval over which this
	 * statistic is representative.
	 */
	public UnsignedInt64Statistic(UnsignedInt64 value, Date start,
	    Date end)
	{
		super(value, start, end);
	}

	public Double getDoubleValue()
	{
		return (new Double(((UnsignedInt64) getValue()).longValue()));
	}

	public Long getLongValue()
	{
		return (new Long(((UnsignedInt64) getValue()).longValue()));
	}

	public UnsignedInt64 getUnsignedInt64Value()
	{
		return ((UnsignedInt64) getValue());
	}

	public AggregateStatistic add(AggregateStatistic o)
	{
		UnsignedInt64 v1 = getUnsignedInt64Value();
		UnsignedInt64 v2 = o.getUnsignedInt64Value();

		return (new UnsignedInt64Statistic(
		    new UnsignedInt64(v1.add(v2)),
		        getStart(), getEnd()));
	}

	public AggregateStatistic subtract(AggregateStatistic o)
	{
		UnsignedInt64 v1 = getUnsignedInt64Value();
		UnsignedInt64 v2 =  o.getUnsignedInt64Value();

		return (new UnsignedInt64Statistic(
		    new UnsignedInt64(v1.subtract(v2)),
		        getStart(), getEnd()));
	}

	public AggregateStatistic getSnapshotForInterval(Iterator it,
	    Date start, Date end) throws IllegalArgumentException
	{
		BigInteger total = new BigInteger("0");
		int count = 0;
		Date first = start, last = end;
		while (it.hasNext()) {
			UnsignedInt64Statistic s = (UnsignedInt64Statistic)
			    it.next();
			if (start != null) {
				if (s.getStart().compareTo(start) < 0)
					continue;
			}
			if (first == null)
				first = s.getStart();

			if (end != null) {
				if (s.getEnd().compareTo(end) > 0)
					continue;
			}
			last = s.getEnd();
			total = total.add(s.getUnsignedInt64Value());
			count++;
		}
		if (count == 0)
			throw new IllegalArgumentException("Cannot derive a " +
			    "snapshot from an empty iterator");
		return (new UnsignedInt64Statistic(
		    new UnsignedInt64(total.divide(new BigInteger(
	            Integer.toString(count)))), first, last));
	}
}