/* 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: ReportProperties.java,v 1.1.1.1 2004/05/09 16:57:38 vlad_r Exp $
*/
package com.vladium.emma.report;
import java.io.File;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
import com.vladium.util.Files;
import com.vladium.util.IProperties;
import com.vladium.util.IntIntMap;
import com.vladium.util.IntVector;
import com.vladium.util.ObjectIntMap;
import com.vladium.util.Property;
import com.vladium.util.asserts.$assert;
import com.vladium.emma.IAppErrorCodes;
import com.vladium.emma.EMMARuntimeException;
// ----------------------------------------------------------------------------
/**
* @author Vlad Roubtsov, (C) 2003
*/
public
abstract class ReportProperties implements IAppErrorCodes
{
// public: ................................................................
public static final IProperties.IMapper REPORT_PROPERTY_MAPPER; // set in <clinit>
public static final class ParsedProperties
{
public void setOutEncoding (final String outEncoding)
{
if ($assert.ENABLED) $assert.ASSERT (outEncoding != null, "null input: outEncoding");
m_outEncoding = outEncoding;
}
public String getOutEncoding ()
{
return m_outEncoding;
}
public void setOutDir (final File outDir)
{
if ($assert.ENABLED) $assert.ASSERT (outDir != null, "null input: outDir");
m_outDir = outDir;
}
public File getOutDir ()
{
return m_outDir;
}
public void setOutFile (final File outFile)
{
if ($assert.ENABLED) $assert.ASSERT (outFile != null, "null input: outFile");
m_outFile = outFile;
}
public File getOutFile ()
{
return m_outFile;
}
public void setUnitsType (final int unitsType)
{
if ($assert.ENABLED) $assert.ASSERT (unitsType >= IItemAttribute.UNITS_COUNT && unitsType <= IItemAttribute.UNITS_INSTR, "invalid units type: " + unitsType);
m_unitsType = unitsType;
}
public int getUnitsType ()
{
return m_unitsType;
}
public void setViewType (final int viewType)
{
if ($assert.ENABLED) $assert.ASSERT (viewType >= IReportDataView.HIER_CLS_VIEW && viewType <= IReportDataView.HIER_SRC_VIEW, "invalid view type: " + viewType);
m_viewType = viewType;
}
public int getViewType ()
{
return m_viewType;
}
public void setDepth (final int depth)
{
if ($assert.ENABLED) $assert.ASSERT (depth >= IItemMetadata.TYPE_ID_ALL && depth <= IItemMetadata.TYPE_ID_METHOD, "invalid depth: " + depth);
m_depth = depth;
}
public int getDepth()
{
return m_depth;
}
public void setHideClasses (final boolean hideClasses)
{
m_hideClasses = hideClasses;
}
public boolean getHideClasses ()
{
return m_hideClasses;
}
public void setColumnOrder (final int [] columnOrder)
{
if ($assert.ENABLED) $assert.ASSERT (columnOrder != null && columnOrder.length != 0, "null/empty input: outEncoding");
m_columnOrder = columnOrder;
}
public int [] getColumnOrder ()
{
return m_columnOrder;
}
public void setSortOrder (final int [] sortOrder)
{
if ($assert.ENABLED) $assert.ASSERT (sortOrder != null, "null input: sortOrder");
m_sortOrder = sortOrder;
}
public int [] getSortOrder ()
{
return m_sortOrder;
}
public void setMetrics (final IntIntMap metrics)
{
if ($assert.ENABLED) $assert.ASSERT (metrics != null, "null input: metrics");
m_metrics = metrics;
}
public IntIntMap getMetrics ()
{
return m_metrics;
}
// TODO: toString/logging
void validate () throws IllegalArgumentException
{
if ($assert.ENABLED)
{
$assert.ASSERT (m_outEncoding != null, "m_outEncoding not set");
$assert.ASSERT (m_outDir != null || m_outFile != null, "either m_outDir or m_outFile must be set");
$assert.ASSERT (m_columnOrder != null, "m_columnOrder not set");
$assert.ASSERT (m_sortOrder != null, "m_sortOrder not set");
$assert.ASSERT (m_metrics != null, "m_metrics not set");
}
}
private String m_outEncoding;
private File m_outDir;
private File m_outFile;
private int m_unitsType;
private int m_viewType;
private boolean m_hideClasses;
private int m_depth;
// TODO: fraction/number format strings...
private int [] m_columnOrder; // attribute IDs [order indicates column order]
private int [] m_sortOrder; // if m_sortOrder[i+1]>0 , sort m_columnOrder[m_sortOrder[i]] in ascending order
private IntIntMap m_metrics; // pass criteria (column attribute ID -> metric)
} // end of nested class
// /**
// * Creates a property view specific to 'reportType' report type.
// *
// * @param appProperties
// * @param reportType
// * @return
// */
// public static Properties getReportProperties (final Properties appProperties, final String reportType)
// {
// if ((reportType == null) || (reportType.length () == 0))
// throw new IllegalArgumentException ("null/empty input: reportType");
//
// if (appProperties == null) return new XProperties ();
//
// return new ReportPropertyLookup (appProperties, reportType);
// }
// /**
// * @param type [null/empty indicates type-neutral property]
// */
// public static String getReportProperty (final String type, final Map properties, final String key)
// {
// if (properties == null) throw new IllegalArgumentException ("null input: properties");
// if (key == null) throw new IllegalArgumentException ("null input: key");
//
// String fullKey;
//
// if ((type == null) || (type.length () == 0))
// fullKey = IReportParameters.PREFIX.concat (key);
// else
// {
// fullKey = IReportParameters.PREFIX.concat (type).concat (".").concat (key);
//
// if (! properties.containsKey (fullKey)) // default to type-neutral lookup
// fullKey = IReportParameters.PREFIX.concat (key);
// }
//
// return (String) properties.get (fullKey);
// }
//
// public static String getReportParameter (final String type, final Map properties, final String key, final String def)
// {
// final String value = getReportProperty (type, properties, key);
//
// return (value == null) ? def : value;
// }
public static ParsedProperties parseProperties (final IProperties properties, final String type)
{
if ($assert.ENABLED) $assert.ASSERT (properties != null, "properties = null");
final ParsedProperties result = new ParsedProperties ();
{
result.setOutEncoding (getReportProperty (properties, type, IReportProperties.OUT_ENCODING, false));
}
// TODO: outDirName is no longer supported
{
final String outDirName = getReportProperty (properties, type, IReportProperties.OUT_DIR, true);
final String outFileName = getReportProperty (properties, type, IReportProperties.OUT_FILE, false);
// renormalize the out dir and file combination:
if (outFileName != null)
{
final File fullOutFile = Files.newFile (outDirName, outFileName);
final File dir = fullOutFile.getParentFile ();
if (dir != null) result.setOutDir (dir);
result.setOutFile (new File (fullOutFile.getName ()));
}
else if (outDirName != null)
{
result.setOutDir (new File (outDirName));
}
}
{
final String unitsType = getReportProperty (properties, type, IReportProperties.UNITS_TYPE, true, IReportProperties.DEFAULT_UNITS_TYPE);
result.setUnitsType (IReportProperties.COUNT_UNITS.equals (unitsType) ? IItemAttribute.UNITS_COUNT : IItemAttribute.UNITS_INSTR);
// TODO: invalid setting not checked
}
{
/* view type is no longer a user-overridable property [it is driven by SourceFile attribute presence]
final String viewType = getReportProperty (properties, type, IReportProperties.VIEW_TYPE, IReportProperties.DEFAULT_VIEW_TYPE);
result.setViewType (IReportProperties.SRC_VIEW.equals (viewType) ? IReportDataView.HIER_SRC_VIEW : IReportDataView.HIER_CLS_VIEW);
*/
result.setViewType (IReportDataView.HIER_SRC_VIEW);
}
{
final String hideClasses = getReportProperty (properties, type, IReportProperties.HIDE_CLASSES, true, IReportProperties.DEFAULT_HIDE_CLASSES);
result.setHideClasses (Property.toBoolean (hideClasses));
// TODO: log this
if (result.getViewType () == IReportDataView.HIER_CLS_VIEW)
result.setHideClasses (false);
}
{
final String depth = getReportProperty (properties, type, IReportProperties.DEPTH, false, IReportProperties.DEFAULT_DEPTH);
if (IReportProperties.DEPTH_ALL.equals (depth))
result.setDepth (AllItem.getTypeMetadata ().getTypeID ());
else if (IReportProperties.DEPTH_PACKAGE.equals (depth))
result.setDepth (PackageItem.getTypeMetadata ().getTypeID ());
else if (IReportProperties.DEPTH_SRCFILE.equals (depth))
result.setDepth (SrcFileItem.getTypeMetadata ().getTypeID ());
else if (IReportProperties.DEPTH_CLASS.equals (depth))
result.setDepth (ClassItem.getTypeMetadata ().getTypeID ());
else if (IReportProperties.DEPTH_METHOD.equals (depth))
result.setDepth (MethodItem.getTypeMetadata ().getTypeID ());
else
// TODO: properly prefixes prop name
throw new EMMARuntimeException (INVALID_PARAMETER_VALUE, new Object [] {IReportProperties.DEPTH, depth});
}
if (result.getHideClasses () &&
(result.getViewType () == IReportDataView.HIER_SRC_VIEW) &&
(result.getDepth () == IItemMetadata.TYPE_ID_CLASS))
{
result.setDepth (IItemMetadata.TYPE_ID_SRCFILE);
}
final Set /* String */ columnNames = new HashSet ();
{
final String columnList = getReportProperty (properties, type, IReportProperties.COLUMNS, false, IReportProperties.DEFAULT_COLUMNS);
final IntVector _columns = new IntVector ();
final int [] out = new int [1];
for (StringTokenizer tokenizer = new StringTokenizer (columnList, ","); tokenizer.hasMoreTokens (); )
{
final String columnName = tokenizer.nextToken ().trim ();
if (! COLUMNS.get (columnName, out))
{
// TODO: generate the entire enum list in the err msg
throw new EMMARuntimeException (INVALID_COLUMN_NAME, new Object [] {columnName});
}
if (! REMOVE_DUPLICATE_COLUMNS || ! columnNames.contains (columnName))
{
columnNames.add (columnName);
_columns.add (out [0]);
}
}
result.setColumnOrder (_columns.values ());
}
// [assertion: columnNames contains all columns for the report (some
// may get removed later by individual report generators if some debug info
// is missing)]
{
final String sortList = getReportProperty (properties, type, IReportProperties.SORT, false, IReportProperties.DEFAULT_SORT);
final IntVector _sort = new IntVector ();
final int [] out = new int [1];
for (StringTokenizer tokenizer = new StringTokenizer (sortList, ","); tokenizer.hasMoreTokens (); )
{
final String sortSpec = tokenizer.nextToken ().trim ();
final String columnName;
final int dir;
switch (sortSpec.charAt (0))
{
case IReportProperties.ASC:
{
dir = +1;
columnName = sortSpec.substring (1);
}
break;
case IReportProperties.DESC:
{
dir = -1;
columnName = sortSpec.substring (1);
}
break;
default:
{
dir = +1;
columnName = sortSpec;
}
break;
} // end of switch
// silently ignore columns not in the column list:
if (columnNames.contains (columnName))
{
COLUMNS.get (columnName, out);
_sort.add (out [0]); // sort attribute ID
_sort.add (dir); // sort direction
}
result.setSortOrder (_sort.values ());
}
}
{
final String metricList = getReportProperty (properties, type, IReportProperties.METRICS, true, IReportProperties.DEFAULT_METRICS);
final IntIntMap _metrics = new IntIntMap ();
final int [] out = new int [1];
// TODO: perhaps should throw on invalid input here
for (StringTokenizer tokenizer = new StringTokenizer (metricList, ","); tokenizer.hasMoreTokens (); )
{
final String metricSpec = tokenizer.nextToken ().trim ();
final String columnName;
final double criterion;
final int separator = metricSpec.indexOf (IReportProperties.MSEPARATOR);
if (separator > 0) // silently ignore invalid entries
{
// silently ignore invalid cutoff values:
try
{
criterion = Double.parseDouble (metricSpec.substring (separator + 1));
if ((criterion < 0.0) || (criterion > 101.0)) continue;
}
catch (NumberFormatException nfe)
{
nfe.printStackTrace (System.out);
continue;
}
columnName = metricSpec.substring (0, separator);
// silently ignore columns not in the column list:
if (columnNames.contains (columnName))
{
COLUMNS.get (columnName, out);
_metrics.put (out [0], (int) Math.round (((criterion * IItem.PRECISION) / 100.0)));
}
}
}
result.setMetrics (_metrics);
}
result.validate ();
return result;
}
// protected: .............................................................
// package: ...............................................................
// private: ...............................................................
private static final class ReportPropertyMapper implements IProperties.IMapper
{
public String getMappedKey (final String key)
{
if (key != null)
{
if (key.startsWith (IReportProperties.PREFIX))
{
final int secondDot = key.indexOf ('.', IReportProperties.PREFIX.length ());
if (secondDot > 0)
{
// TODO: make this more precise (actually check the report type value string)
return IReportProperties.PREFIX.concat (key.substring (secondDot + 1));
}
}
}
return null;
}
} // end of nested class
// private static final class ReportPropertyLookup extends XProperties
// {
// // note: due to incredibly stupid coding in java.util.Properties
// // (getProperty() uses a non-virtual call to super.get(), while propertyNames()
// // uses a virtual call to the same method instead of delegating to getProperty())
// // I must override both methods below
//
// public String getProperty (String key)
// {
// return (String) get (key);
// }
//
// // TODO: this kind of lookup makes the property listing confusing
//
// public Object get (final Object _key)
// {
// if (! (_key instanceof String)) return null;
//
// String key = (String) _key;
//
// if (key.startsWith (IReportProperties.PREFIX))
// key = key.substring (IReportProperties.PREFIX.length ());
//
// if (key.startsWith (m_reportType))
// key = key.substring (m_reportType.length () + 1);
//
// String fullKey = IReportProperties.PREFIX.concat (m_reportType).concat (".").concat (key);
//
// String result = defaults.getProperty (fullKey, null);
// if (result != null) return result;
//
// // fall back to report type-neutral namespace:
// fullKey = IReportProperties.PREFIX.concat (key);
//
// result = defaults.getProperty (fullKey, null);
// if (result != null) return result;
//
// return null;
// }
//
//
// ReportPropertyLookup (final Properties appProperties, final String reportType)
// {
// super (appProperties);
//
// m_reportType = reportType;
// }
//
//
// private final String m_reportType; // never null or empty [factory-ensured]
//
// } // end of nested class
private ReportProperties () {} // prevent subclassing
private static String getReportProperty (final IProperties properties, final String type, final String key, final boolean allowBlank)
{
return getReportProperty (properties, type, key, allowBlank, null);
}
private static String getReportProperty (final IProperties properties, final String type, final String key, final boolean allowBlank, final String dflt)
{
if ($assert.ENABLED) $assert.ASSERT (properties != null, "null input: properties");
if ($assert.ENABLED) $assert.ASSERT (key != null, "null input: key");
final String result = properties.getProperty (IReportProperties.PREFIX.concat (type).concat (".").concat (key), dflt);
if (! allowBlank && (result != null) && (result.trim ().length () == 0))
return dflt;
else
return result;
}
private static final boolean REMOVE_DUPLICATE_COLUMNS = true;
private static final ObjectIntMap /* col name:String -> metadata:IItemMetadata */ COLUMNS; // set in <clinit>
static
{
REPORT_PROPERTY_MAPPER = new ReportPropertyMapper ();
final ObjectIntMap columns = new ObjectIntMap ();
columns.put (IReportProperties.ITEM_NAME_COLUMN, IItemAttribute.ATTRIBUTE_NAME_ID);
columns.put (IReportProperties.CLASS_COVERAGE_COLUMN, IItemAttribute.ATTRIBUTE_CLASS_COVERAGE_ID);
columns.put (IReportProperties.METHOD_COVERAGE_COLUMN, IItemAttribute.ATTRIBUTE_METHOD_COVERAGE_ID);
columns.put (IReportProperties.BLOCK_COVERAGE_COLUMN, IItemAttribute.ATTRIBUTE_BLOCK_COVERAGE_ID);
columns.put (IReportProperties.LINE_COVERAGE_COLUMN, IItemAttribute.ATTRIBUTE_LINE_COVERAGE_ID);
COLUMNS = columns;
}
} // end of class
// ---------------------------------------------------------------------------- |
