core/java12/com/vladium/emma/report/IItemAttribute.java - platform/external/emma - Git at Google

 /* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
  *
  * This program and the accompanying materials are made available under
  * the terms of the Common Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/cpl-v10.html
  *
  * $Id: IItemAttribute.java,v 1.1.1.1.2.1 2004/07/10 19:08:50 vlad_r Exp $
  */
 package com.vladium.emma.report;

 import java.text.DecimalFormat;
 import java.text.FieldPosition;
 import java.text.NumberFormat;
 import java.util.Comparator;

 import com.vladium.util.asserts.$assert;

 // ----------------------------------------------------------------------------
 /**
  * @author Vlad Roubtsov, (C) 2003
  */
 public
 interface IItemAttribute
 {
     // public: ................................................................

     // TODO: this modeling (units is an independent axis) is not ideal, because
     // not all of the attributes have meaningful separation by unit type

     // note: the ordering is consistent with code in Factory:

     int ATTRIBUTE_NAME_ID               = 0;
     int ATTRIBUTE_CLASS_COVERAGE_ID     = 1;
     int ATTRIBUTE_METHOD_COVERAGE_ID    = 2;
     int ATTRIBUTE_BLOCK_COVERAGE_ID     = 3;
     int ATTRIBUTE_LINE_COVERAGE_ID      = 4;

     // note: the ordering is consistent with code in Factory and SrcFileItem:

     int UNITS_COUNT = 0;
     int UNITS_INSTR = 1;

     Comparator /* IItem */ comparator ();
     String getName ();
     void format (IItem item, StringBuffer appendTo);
     boolean passes (IItem item, int criterion); // ideally, criteria should come from a double-dispatched API


     abstract class Factory
     {
         public static IItemAttribute getAttribute (final int attributeID, final int unitsID)
         {
             if ($assert.ENABLED) $assert.ASSERT (attributeID >= ATTRIBUTE_NAME_ID && attributeID <= ATTRIBUTE_LINE_COVERAGE_ID, "invalid attribute ID: " + attributeID);
             if ($assert.ENABLED) $assert.ASSERT (unitsID >= UNITS_COUNT && unitsID <= UNITS_INSTR, "invalid units ID: " + unitsID);

             return ATTRIBUTES [unitsID][attributeID];
         }

         public static IItemAttribute [] getAttributes (final int unitsID)
         {
             if ($assert.ENABLED) $assert.ASSERT (unitsID >= UNITS_COUNT && unitsID <= UNITS_INSTR, "invalid units ID: " + unitsID);

             return (IItemAttribute []) ATTRIBUTES [unitsID].clone ();
         }

         private static abstract class Attribute implements IItemAttribute
         {
             public String getName ()
             {
                 return m_name;
             }

              protected Attribute (final String name)
             {
                 if (name == null) throw new IllegalArgumentException ("null input: name");

                 m_name = name;
             }


             private final String m_name;

         } // end of nested class


         private static final class NameAttribute extends Attribute
                                                  implements IItemAttribute
         {
             public Comparator comparator ()
             {
                 return m_comparator;
             }

             public void format (final IItem item, final StringBuffer appendTo)
             {
                 appendTo.append (item.getName ());
             }

             public boolean passes (final IItem item, final int criterion)
             {
                 return true; // names always pass [for now]
             }


             private static final class NameComparator implements Comparator
             {
                 public int compare (final Object l, final Object g)
                 {
                     final IItem il = (IItem) l;
                     final IItem ig = (IItem) g;

                     return il.getName ().compareTo (ig.getName ());
                 }

             } // end of nested class

             NameAttribute (final String name)
             {
                 super (name);

                 m_comparator = new NameComparator ();
             }


             private final Comparator m_comparator;

         } // end of nested class


         private static final class FractionAttribute extends Attribute
                                                      implements IItemAttribute
         {
             public Comparator comparator ()
             {
                 return m_comparator;
             }

             public void format (final IItem item, final StringBuffer appendTo)
             {
                 final int n = item.getAggregate (m_numeratorAggregateID);
                 final double n_scaled = (double) n / m_scale;
                 final int d = item.getAggregate (m_denominatorAggregateID);

                 // d can be 0 legally: the compiler can generate classes with no methods in them [happens with synthetic classes, for example]
                 //if ($assert.ENABLED) $assert.ASSERT (d > 0, "[attr ID = " + m_denominatorAggregateID + "] invalid denominator: " + d);

                 final int appendToStart = appendTo.length ();

                 if (d == 0)
                     m_format.format (1.0F, appendTo, m_fieldPosition);
                 else
                     m_format.format (n_scaled / d, appendTo, m_fieldPosition);

                 final int iLimit = Math.max (1, 5 - appendTo.length () + appendToStart);
                 for (int i = 0; i < iLimit; ++ i) appendTo.append (' ');

                 appendTo.append ('(');
                 m_nFormat.format (n_scaled, appendTo, m_fieldPosition);
                 appendTo.append ('/');
                 appendTo.append (d);
                 appendTo.append (')');
             }

             public boolean passes (final IItem item, final int criterion)
             {
                 final int n = item.getAggregate (m_numeratorAggregateID);
                 final int d = item.getAggregate (m_denominatorAggregateID);

                 return ((double) n) * IItem.PRECISION >=  ((double) d) * m_scale * criterion;
             }


             private final class FractionComparator implements Comparator
             {
                 public int compare (final Object l, final Object g)
                 {
                     final IItem il = (IItem) l;
                     final IItem ig = (IItem) g;

                     final double nil = il.getAggregate (m_numeratorAggregateID);
                     final double dil = il.getAggregate (m_denominatorAggregateID);

                     final double nig = ig.getAggregate (m_numeratorAggregateID);
                     final double dig = ig.getAggregate (m_denominatorAggregateID);

                     final double diff = nil * dig - nig * dil;

                     return diff > 0.0 ? +1 : (diff < 0.0 ? -1 : 0);
                 }

             } // end of inner class


             FractionAttribute (final String name, final int numeratorAggregateID, final int denominatorAggregateID, final int scale, final int nFractionDigits)
             {
                 super (name);

                 if ($assert.ENABLED) $assert.ASSERT (scale != 0, "scale: " + scale);

                 m_numeratorAggregateID = numeratorAggregateID;
                 m_denominatorAggregateID = denominatorAggregateID; // ok to be zero
                 m_scale = scale;

                 m_format = (DecimalFormat) NumberFormat.getPercentInstance (); // TODO: locale
                 m_fieldPosition = new FieldPosition (DecimalFormat.INTEGER_FIELD);

                 // TODO: set this from a pattern property
                 //m_format.setMinimumFractionDigits (1);
                 m_format.setMaximumFractionDigits (0);
                 //m_format.setDecimalSeparatorAlwaysShown (false);

                 m_nFormat = (DecimalFormat) NumberFormat.getInstance (); // TODO: locale
                 m_nFormat.setGroupingUsed (false);
                 m_nFormat.setMaximumFractionDigits (nFractionDigits);

                 m_comparator = new FractionComparator ();
             }


             final int m_numeratorAggregateID, m_denominatorAggregateID;

             private final int m_scale;
             private final DecimalFormat m_format, m_nFormat;
             private final FieldPosition m_fieldPosition;
             private final Comparator m_comparator;

         } // end of nested class


         private Factory () {}

         private static final IItemAttribute [/* unit */][/* attributes */] ATTRIBUTES; // set in <clinit>

         static
         {
             final IItemAttribute nameAttribute = new NameAttribute ("name");

             final IItemAttribute classCoverageAttribute = new FractionAttribute ("class, %", IItem.COVERAGE_CLASS_COUNT, IItem.TOTAL_CLASS_COUNT, 1, 0);
             final IItemAttribute methodCoverageAttribute = new FractionAttribute ("method, %", IItem.COVERAGE_METHOD_COUNT, IItem.TOTAL_METHOD_COUNT, 1, 0);

             ATTRIBUTES = new IItemAttribute [][]
             {
                 /* count: */
                 {
                     nameAttribute,
                     classCoverageAttribute,
                     methodCoverageAttribute,
                     new FractionAttribute ("block, %", IItem.COVERAGE_BLOCK_COUNT, IItem.TOTAL_BLOCK_COUNT, 1, 0),
                     new FractionAttribute ("line, %", IItem.COVERAGE_LINE_COUNT, IItem.TOTAL_LINE_COUNT, IItem.PRECISION, 1),
                 },
                 /* instr: */
                 {
                     nameAttribute,
                     classCoverageAttribute,
                     methodCoverageAttribute,
                     new FractionAttribute ("block, %", IItem.COVERAGE_BLOCK_INSTR, IItem.TOTAL_BLOCK_INSTR, 1, 0),
                     new FractionAttribute ("line, %", IItem.COVERAGE_LINE_INSTR, IItem.TOTAL_LINE_COUNT, IItem.PRECISION, 1),
                 },
             };
         }

     } // end of nested class

 } // end of interface
 // ----------------------------------------------------------------------------
	/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
	*
	* This program and the accompanying materials are made available under
	* the terms of the Common Public License v1.0 which accompanies this distribution,
	* and is available at http://www.eclipse.org/legal/cpl-v10.html
	*
	* $Id: IItemAttribute.java,v 1.1.1.1.2.1 2004/07/10 19:08:50 vlad_r Exp $
	*/
	package com.vladium.emma.report;

	import java.text.DecimalFormat;
	import java.text.FieldPosition;
	import java.text.NumberFormat;
	import java.util.Comparator;

	import com.vladium.util.asserts.$assert;

	// ----------------------------------------------------------------------------
	/**
	* @author Vlad Roubtsov, (C) 2003
	*/
	public
	interface IItemAttribute
	{
	// public: ................................................................

	// TODO: this modeling (units is an independent axis) is not ideal, because
	// not all of the attributes have meaningful separation by unit type

	// note: the ordering is consistent with code in Factory:

	int ATTRIBUTE_NAME_ID = 0;
	int ATTRIBUTE_CLASS_COVERAGE_ID = 1;
	int ATTRIBUTE_METHOD_COVERAGE_ID = 2;
	int ATTRIBUTE_BLOCK_COVERAGE_ID = 3;
	int ATTRIBUTE_LINE_COVERAGE_ID = 4;

	// note: the ordering is consistent with code in Factory and SrcFileItem:

	int UNITS_COUNT = 0;
	int UNITS_INSTR = 1;

	Comparator /* IItem */ comparator ();
	String getName ();
	void format (IItem item, StringBuffer appendTo);
	boolean passes (IItem item, int criterion); // ideally, criteria should come from a double-dispatched API


	abstract class Factory
	{
	public static IItemAttribute getAttribute (final int attributeID, final int unitsID)
	{
	if ($assert.ENABLED) $assert.ASSERT (attributeID >= ATTRIBUTE_NAME_ID && attributeID <= ATTRIBUTE_LINE_COVERAGE_ID, "invalid attribute ID: " + attributeID);
	if ($assert.ENABLED) $assert.ASSERT (unitsID >= UNITS_COUNT && unitsID <= UNITS_INSTR, "invalid units ID: " + unitsID);

	return ATTRIBUTES [unitsID][attributeID];
	}

	public static IItemAttribute [] getAttributes (final int unitsID)
	{
	if ($assert.ENABLED) $assert.ASSERT (unitsID >= UNITS_COUNT && unitsID <= UNITS_INSTR, "invalid units ID: " + unitsID);

	return (IItemAttribute []) ATTRIBUTES [unitsID].clone ();
	}

	private static abstract class Attribute implements IItemAttribute
	{
	public String getName ()
	{
	return m_name;
	}

	protected Attribute (final String name)
	{
	if (name == null) throw new IllegalArgumentException ("null input: name");

	m_name = name;
	}


	private final String m_name;

	} // end of nested class


	private static final class NameAttribute extends Attribute
	implements IItemAttribute
	{
	public Comparator comparator ()
	{
	return m_comparator;
	}

	public void format (final IItem item, final StringBuffer appendTo)
	{
	appendTo.append (item.getName ());
	}

	public boolean passes (final IItem item, final int criterion)
	{
	return true; // names always pass [for now]
	}


	private static final class NameComparator implements Comparator
	{
	public int compare (final Object l, final Object g)
	{
	final IItem il = (IItem) l;
	final IItem ig = (IItem) g;

	return il.getName ().compareTo (ig.getName ());
	}

	} // end of nested class

	NameAttribute (final String name)
	{
	super (name);

	m_comparator = new NameComparator ();
	}


	private final Comparator m_comparator;

	} // end of nested class


	private static final class FractionAttribute extends Attribute
	implements IItemAttribute
	{
	public Comparator comparator ()
	{
	return m_comparator;
	}

	public void format (final IItem item, final StringBuffer appendTo)
	{
	final int n = item.getAggregate (m_numeratorAggregateID);
	final double n_scaled = (double) n / m_scale;
	final int d = item.getAggregate (m_denominatorAggregateID);

	// d can be 0 legally: the compiler can generate classes with no methods in them [happens with synthetic classes, for example]
	//if ($assert.ENABLED) $assert.ASSERT (d > 0, "[attr ID = " + m_denominatorAggregateID + "] invalid denominator: " + d);

	final int appendToStart = appendTo.length ();

	if (d == 0)
	m_format.format (1.0F, appendTo, m_fieldPosition);
	else
	m_format.format (n_scaled / d, appendTo, m_fieldPosition);

	final int iLimit = Math.max (1, 5 - appendTo.length () + appendToStart);
	for (int i = 0; i < iLimit; ++ i) appendTo.append (' ');

	appendTo.append ('(');
	m_nFormat.format (n_scaled, appendTo, m_fieldPosition);
	appendTo.append ('/');
	appendTo.append (d);
	appendTo.append (')');
	}

	public boolean passes (final IItem item, final int criterion)
	{
	final int n = item.getAggregate (m_numeratorAggregateID);
	final int d = item.getAggregate (m_denominatorAggregateID);

	return ((double) n) * IItem.PRECISION >= ((double) d) * m_scale * criterion;
	}


	private final class FractionComparator implements Comparator
	{
	public int compare (final Object l, final Object g)
	{
	final IItem il = (IItem) l;
	final IItem ig = (IItem) g;

	final double nil = il.getAggregate (m_numeratorAggregateID);
	final double dil = il.getAggregate (m_denominatorAggregateID);

	final double nig = ig.getAggregate (m_numeratorAggregateID);
	final double dig = ig.getAggregate (m_denominatorAggregateID);

	final double diff = nil * dig - nig * dil;

	return diff > 0.0 ? +1 : (diff < 0.0 ? -1 : 0);
	}

	} // end of inner class


	FractionAttribute (final String name, final int numeratorAggregateID, final int denominatorAggregateID, final int scale, final int nFractionDigits)
	{
	super (name);

	if ($assert.ENABLED) $assert.ASSERT (scale != 0, "scale: " + scale);

	m_numeratorAggregateID = numeratorAggregateID;
	m_denominatorAggregateID = denominatorAggregateID; // ok to be zero
	m_scale = scale;

	m_format = (DecimalFormat) NumberFormat.getPercentInstance (); // TODO: locale
	m_fieldPosition = new FieldPosition (DecimalFormat.INTEGER_FIELD);

	// TODO: set this from a pattern property
	//m_format.setMinimumFractionDigits (1);
	m_format.setMaximumFractionDigits (0);
	//m_format.setDecimalSeparatorAlwaysShown (false);

	m_nFormat = (DecimalFormat) NumberFormat.getInstance (); // TODO: locale
	m_nFormat.setGroupingUsed (false);
	m_nFormat.setMaximumFractionDigits (nFractionDigits);

	m_comparator = new FractionComparator ();
	}


	final int m_numeratorAggregateID, m_denominatorAggregateID;

	private final int m_scale;
	private final DecimalFormat m_format, m_nFormat;
	private final FieldPosition m_fieldPosition;
	private final Comparator m_comparator;

	} // end of nested class



	private Factory () {}

	private static final IItemAttribute [/* unit /][/ attributes */] ATTRIBUTES; // set in <clinit>

	static
	{
	final IItemAttribute nameAttribute = new NameAttribute ("name");

	final IItemAttribute classCoverageAttribute = new FractionAttribute ("class, %", IItem.COVERAGE_CLASS_COUNT, IItem.TOTAL_CLASS_COUNT, 1, 0);
	final IItemAttribute methodCoverageAttribute = new FractionAttribute ("method, %", IItem.COVERAGE_METHOD_COUNT, IItem.TOTAL_METHOD_COUNT, 1, 0);

	ATTRIBUTES = new IItemAttribute [][]
	{
	/* count: */
	{
	nameAttribute,
	classCoverageAttribute,
	methodCoverageAttribute,
	new FractionAttribute ("block, %", IItem.COVERAGE_BLOCK_COUNT, IItem.TOTAL_BLOCK_COUNT, 1, 0),
	new FractionAttribute ("line, %", IItem.COVERAGE_LINE_COUNT, IItem.TOTAL_LINE_COUNT, IItem.PRECISION, 1),
	},
	/* instr: */
	{
	nameAttribute,
	classCoverageAttribute,
	methodCoverageAttribute,
	new FractionAttribute ("block, %", IItem.COVERAGE_BLOCK_INSTR, IItem.TOTAL_BLOCK_INSTR, 1, 0),
	new FractionAttribute ("line, %", IItem.COVERAGE_LINE_INSTR, IItem.TOTAL_LINE_COUNT, IItem.PRECISION, 1),
	},
	};
	}

	} // end of nested class

	} // end of interface
	// ----------------------------------------------------------------------------