JRDesignCrosstab.java
| Index Score | ||
|---|---|---|
 |
 |
net.sf.jasperreports.crosstabs.design |
 |
 |
JasperReports |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| LOOPS | Number of loops |  |
| CYCLOMATIC | Cyclomatic complexity | |
| OPERATORS | Number of operators | |
| LOGICAL_LINES | Number of statements | |
| PROGRAM_LENGTH | Halstead program length | |
| LOC | Lines of code | |
| OPERANDS | Number of operands | |
| BLOCKS | Number of blocks | |
| FUNCTIONS | Number of function declarations | |
| LINES | Number of lines in the source file | |
| COMPARISONS | Number of comparison operators | |
| JAVA0254 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| SIZE | Size of the file in bytes | |
| EXITS | Procedure exits | |
| ELOC | Effective lines of code | |
| UNIQUE_OPERANDS | Number of unique operands | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| RETURNS | Number of return points from functions | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| PARAMS | Number of formal parameter declarations | |
| WHITESPACE | Number of whitespace lines | |
| DECL_COMMENTS | Comments in declarations | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
| DOC_COMMENT | Number of javadoc comment lines | |
| JAVA0116 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0119 | JAVA0119 Control variable changed within body of for loop | |
| COMMENTS | Comment lines | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| JAVA0259 | JAVA0259 Return of collection/array field | |
| JAVA0144 | JAVA0144 Line exceeds maximum M characters | |
| UNIQUE_OPERATORS | Number of unique operators | |
| JAVA0096 | JAVA0096 Field in nested class hides outer field | |
| NEST_DEPTH | Maximum nesting depth | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| EXEC_COMMENTS | Comments in executable code | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| LINE_COMMENT | Number of line comments | |
| JAVA0179 | JAVA0179 Local variable hides visible field | |
| JAVA0100 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0044 | JAVA0044 Serializable class with no instance variables | |
| JAVA0270 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
/*
* ============================================================================
* GNU Lesser General Public License
* ============================================================================
*
* JasperReports - Free Java report-generating library.
* Copyright (C) 2001-2006 JasperSoft Corporation http://www.jaspersoft.com
*
* This library 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.1 of the License, or (at your option) any later version.
*
* This library 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.
*
* JasperSoft Corporation
* 303 Second Street, Suite 450 North
* San Francisco, CA 94107
* http://www.jaspersoft.com
*/
package net.sf.jasperreports.crosstabs.design;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.Serializable;
import java.net.URLStreamHandlerFactory;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.TimeZone;
import net.sf.jasperreports.crosstabs.JRCellContents;
import net.sf.jasperreports.crosstabs.JRCrosstab;
import net.sf.jasperreports.crosstabs.JRCrosstabBucket;
import net.sf.jasperreports.crosstabs.JRCrosstabCell;
import net.sf.jasperreports.crosstabs.JRCrosstabColumnGroup;
import net.sf.jasperreports.crosstabs.JRCrosstabDataset;
import net.sf.jasperreports.crosstabs.JRCrosstabGroup;
import net.sf.jasperreports.crosstabs.JRCrosstabMeasure;
import net.sf.jasperreports.crosstabs.JRCrosstabParameter;
import net.sf.jasperreports.crosstabs.JRCrosstabRowGroup;
import net.sf.jasperreports.crosstabs.base.JRBaseCrosstab;
import net.sf.jasperreports.engine.JRConstants;
import net.sf.jasperreports.engine.JRDefaultStyleProvider;
import net.sf.jasperreports.engine.JRElement;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExpression;
import net.sf.jasperreports.engine.JRExpressionCollector;
import net.sf.jasperreports.engine.JRParameter;
import net.sf.jasperreports.engine.JRVariable;
import net.sf.jasperreports.engine.JRVisitor;
import net.sf.jasperreports.engine.design.JRDesignElement;
import net.sf.jasperreports.engine.design.JRDesignVariable;
import net.sf.jasperreports.engine.util.FileResolver;
import net.sf.jasperreports.engine.util.FormatFactory;
import net.sf.jasperreports.engine.util.JRStyleResolver;
import net.sf.jasperreports.engine.util.Pair;
import org.apache.commons.collections.SequencedHashMap;
/**
* Design-time {@link net.sf.jasperreports.crosstabs.JRCrosstab crosstab} implementation.
*
* @author Lucian Chirita (lucianc@users.sourceforge.net)
* @version $Id: JRDesignCrosstab.java 2145 2008-03-27 10:35:05Z lucianc $
*/
public class JRDesignCrosstab extends JRDesignElement implements JRCrosstab
{
private static final long serialVersionUID = JRConstants.SERIAL_VERSION_UID;
public static final String PROPERTY_COLUMN_BREAK_OFFSET = "columnBreakOffset";
public static final String PROPERTY_DATASET = "dataset";
public static final String PROPERTY_HEADER_CELL = "headerCell";
public static final String PROPERTY_PARAMETERS_MAP_EXPRESSION = "parametersMapExpression";
public static final String PROPERTY_REPEAT_COLUMN_HEADERS = "repeatColumnHeaders";
public static final String PROPERTY_REPEAT_ROW_HEADERS = "repeatRowHeaders";
public static final String PROPERTY_WHEN_NO_DATA_CELL = "whenNoDataCell";
public static final String PROPERTY_CELLS = "cells";
public static final String PROPERTY_ROW_GROUPS = "rowGroups";
public static final String PROPERTY_COLUMN_GROUPS = "columnGroups";
public static final String PROPERTY_MEASURES = "measures";
public static final String PROPERTY_PARAMETERS = "parameters";
protected List parametersList;
protected Map parametersMap;
protected SequencedHashMap variablesList;
protected JRExpression parametersMapExpression;
protected JRDesignCrosstabDataset dataset;
protected List rowGroups;
protected List columnGroups;
protected List measures;
protected Map rowGroupsMap;
protected Map columnGroupsMap;
protected Map measuresMap;
protected int columnBreakOffset = DEFAULT_COLUMN_BREAK_OFFSET;
protected boolean repeatColumnHeaders = true;
protected boolean repeatRowHeaders = true;
protected byte runDirection;
protected List cellsList;
protected Map cellsMap;
protected JRDesignCrosstabCell[][] crossCells;
protected JRDesignCellContents whenNoDataCell;
protected JRDesignCellContents headerCell;
private class MeasureClassChangeListener implements PropertyChangeListener, Serializable
{
private static final long serialVersionUID = JRConstants.SERIAL_VERSION_UID;
public void propertyChange(PropertyChangeEvent evt)
{
measureClassChanged((JRDesignCrosstabMeasure) evt.getSource(), (String) evt.getNewValue());
}
}
private PropertyChangeListener measureClassChangeListener = new MeasureClassChangeListener();
private static final Object[] BUILT_IN_PARAMETERS = new Object[] {
JRParameter.REPORT_PARAMETERS_MAP, java.util.Map.class,
JRParameter.REPORT_LOCALE, Locale.class,
JRParameter.REPORT_RESOURCE_BUNDLE, ResourceBundle.class,
JRParameter.REPORT_TIME_ZONE, TimeZone.class,
JRParameter.REPORT_FORMAT_FACTORY, FormatFactory.class,
JRParameter.REPORT_CLASS_LOADER, ClassLoader.class,
JRParameter.REPORT_URL_HANDLER_FACTORY, URLStreamHandlerFactory.class,
JRParameter.REPORT_FILE_RESOLVER, FileResolver.class};
private static final Object[] BUILT_IN_VARIABLES = new Object[] {
JRCrosstab.VARIABLE_ROW_COUNT, Integer.class,
JRCrosstab.VARIABLE_COLUMN_COUNT, Integer.class};
/**
* Creates a new crosstab.
*
* @param defaultStyleProvider default style provider
*/
public JRDesignCrosstab(JRDefaultStyleProvider defaultStyleProvider)
{
super(defaultStyleProvider);
parametersList = new ArrayList();
parametersMap = new HashMap();
rowGroupsMap = new HashMap();
rowGroups = new ArrayList();
columnGroupsMap = new HashMap();
columnGroups = new ArrayList();
measuresMap = new HashMap();
measures = new ArrayList();
cellsMap = new HashMap();
cellsList = new ArrayList();
addBuiltinParameters();
variablesList = new SequencedHashMap();
addBuiltinVariables();
dataset = new JRDesignCrosstabDataset();
}
private void addBuiltinParameters()
{
for (int i = 0; i < BUILT_IN_PARAMETERS.length; i++)
{
JRDesignCrosstabParameter parameter = new JRDesignCrosstabParameter();
parameter.setName((String) BUILT_IN_PARAMETERS[i++]);
parameter.setValueClass((Class) BUILT_IN_PARAMETERS[i]);
parameter.setSystemDefined(true);
try
{
addParameter(parameter);
}
catch (JRException e)
{
// never reached
}
}
}
private void addBuiltinVariables()
{
for (int i = 0; i < BUILT_IN_VARIABLES.length; ++i)
{
JRDesignVariable variable = new JRDesignVariable();
variable.setName((String) BUILT_IN_VARIABLES[i]);
variable.setValueClass((Class) BUILT_IN_VARIABLES[++i]);
variable.setCalculation(JRVariable.CALCULATION_SYSTEM);
variable.setSystemDefined(true);
addVariable(variable);
}
}
/**
* Creates a new crosstab.
*/
public JRDesignCrosstab()
{
this(null);
}
/**
* The ID of the crosstab is only generated at compile time.
*/
public int getId()
{
return 0;
}
public JRCrosstabDataset getDataset()
{
return dataset;
}
/**
* Returns the crosstab dataset object to be used for report designing.
*
* @return the crosstab dataset design object
*/
public JRDesignCrosstabDataset getDesignDataset()
{
return dataset;
}
public JRCrosstabRowGroup[] getRowGroups()
{
JRCrosstabRowGroup[] groups = new JRCrosstabRowGroup[rowGroups.size()];
rowGroups.toArray(groups);
return groups;
}
public JRCrosstabColumnGroup[] getColumnGroups()
{
JRCrosstabColumnGroup[] groups = new JRCrosstabColumnGroup[columnGroups.size()];
columnGroups.toArray(groups);
return groups;
}
public JRCrosstabMeasure[] getMeasures()
{
JRCrosstabMeasure[] measureArray = new JRCrosstabMeasure[measures.size()];
measures.toArray(measureArray);
return measureArray;
}
public void collectExpressions(JRExpressionCollector collector)
{
collector.collect(this);
}
/**
*
*/
public void visit(JRVisitor visitor)
{
visitor.visitCrosstab(this);
}
/**
* Sets the crosstab input dataset.
*
* @param dataset the dataset
* @see JRCrosstab#getDataset()
*/
public void setDataset(JRDesignCrosstabDataset dataset)
{
Object old = this.dataset;
this.dataset = dataset;
getEventSupport().firePropertyChange(PROPERTY_DATASET, old, this.dataset);
}
/**
* Adds a row group.
* <p>
* This group will be a sub group of the last row group, if any.
*
* @param group the group
* @throws JRException
* @see JRCrosstab#getRowGroups()
*/
public void addRowGroup(JRDesignCrosstabRowGroup group) throws JRException
{
String groupName = group.getName();
if (rowGroupsMap.containsKey(groupName) ||
columnGroupsMap.containsKey(groupName) ||
measuresMap.containsKey(groupName))
{
throw new JRException("A group or measure having the same name already exists in the crosstab.");
}
rowGroupsMap.put(groupName, new Integer(rowGroups.size()));
rowGroups.add(group);
addRowGroupVars(group);
setParent(group);
getEventSupport().fireCollectionElementAddedEvent(PROPERTY_ROW_GROUPS, group, rowGroups.size() - 1);
}
protected void addRowGroupVars(JRDesignCrosstabRowGroup rowGroup)
{
addVariable(rowGroup.getVariable());
for (Iterator measureIt = measures.iterator(); measureIt.hasNext();)
{
JRCrosstabMeasure measure = (JRCrosstabMeasure) measureIt.next();
addTotalVar(measure, rowGroup, null);
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
addTotalVar(measure, rowGroup, colGroup);
}
}
}
/**
* Adds a column group.
* <p>
* This group will be a sub group of the last column group, if any.
*
* @param group the group
* @throws JRException
* @see JRCrosstab#getColumnGroups()
*/
public void addColumnGroup(JRDesignCrosstabColumnGroup group) throws JRException
{
String groupName = group.getName();
if (rowGroupsMap.containsKey(groupName) ||
columnGroupsMap.containsKey(groupName) ||
measuresMap.containsKey(groupName))
{
throw new JRException("A group or measure having the same name already exists in the crosstab.");
}
columnGroupsMap.put(groupName, new Integer(columnGroups.size()));
columnGroups.add(group);
addColGroupVars(group);
setParent(group);
getEventSupport().fireCollectionElementAddedEvent(PROPERTY_COLUMN_GROUPS, group, columnGroups.size() - 1);
}
protected void addColGroupVars(JRDesignCrosstabColumnGroup colGroup)
{
addVariable(colGroup.getVariable());
for (Iterator measureIt = measures.iterator(); measureIt.hasNext();)
{
JRCrosstabMeasure measure = (JRCrosstabMeasure) measureIt.next();
addTotalVar(measure, null, colGroup);
for (Iterator rowIt = rowGroups.iterator(); rowIt.hasNext();)
{
JRCrosstabRowGroup rowGroup = (JRCrosstabRowGroup) rowIt.next();
addTotalVar(measure, rowGroup, colGroup);
}
}
}
/**
* Adds a measure to the crosstab.
*
* @param measure the measure
* @throws JRException
* @see JRCrosstab#getMeasures()
*/
public void addMeasure(JRDesignCrosstabMeasure measure) throws JRException
{
String measureName = measure.getName();
if (rowGroupsMap.containsKey(measureName) ||
columnGroupsMap.containsKey(measureName) ||
measuresMap.containsKey(measureName))
{
throw new JRException("A group or measure having the same name already exists in the crosstab.");
}
measure.addPropertyChangeListener(JRDesignCrosstabMeasure.PROPERTY_VALUE_CLASS, measureClassChangeListener);
measuresMap.put(measureName, new Integer(measures.size()));
measures.add(measure);
addMeasureVars(measure);
getEventSupport().fireCollectionElementAddedEvent(PROPERTY_MEASURES, measure, measures.size() - 1);
}
protected void addMeasureVars(JRDesignCrosstabMeasure measure)
{
addVariable(measure.getVariable());
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
addTotalVar(measure, null, colGroup);
}
for (Iterator rowIt = rowGroups.iterator(); rowIt.hasNext();)
{
JRCrosstabRowGroup rowGroup = (JRCrosstabRowGroup) rowIt.next();
addTotalVar(measure, rowGroup, null);
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
addTotalVar(measure, rowGroup, colGroup);
}
}
}
protected void addTotalVar(JRCrosstabMeasure measure, JRCrosstabRowGroup rowGroup, JRCrosstabColumnGroup colGroup)
{
JRDesignVariable var = new JRDesignVariable();
var.setCalculation(JRVariable.CALCULATION_SYSTEM);
var.setSystemDefined(true);
var.setName(getTotalVariableName(measure, rowGroup, colGroup));
var.setValueClassName(measure.getValueClassName());
addVariable(var);
}
protected void removeTotalVar(JRCrosstabMeasure measure, JRCrosstabRowGroup rowGroup, JRCrosstabColumnGroup colGroup)
{
String varName = getTotalVariableName(measure, rowGroup, colGroup);
removeVariable(varName);
}
public static String getTotalVariableName(JRCrosstabMeasure measure, JRCrosstabRowGroup rowGroup, JRCrosstabColumnGroup colGroup)
{
StringBuffer name = new StringBuffer();
name.append(measure.getName());
if (rowGroup != null)
{
name.append('_');
name.append(rowGroup.getName());
}
if (colGroup != null)
{
name.append('_');
name.append(colGroup.getName());
}
name.append("_ALL");
return name.toString();
}
/**
* Removes a row group.
*
* @param groupName the group name
* @return the removed group
*/
public JRCrosstabRowGroup removeRowGroup(String groupName)
{
JRCrosstabRowGroup removed = null;
Integer idx = (Integer) rowGroupsMap.remove(groupName);
if (idx != null)
{
removed = (JRCrosstabRowGroup) rowGroups.remove(idx.intValue());
for (ListIterator it = rowGroups.listIterator(idx.intValue()); it.hasNext();)
{
JRCrosstabRowGroup group = (JRCrosstabRowGroup) it.next();
rowGroupsMap.put(group.getName(), new Integer(it.previousIndex()));
}
for (Iterator it = cellsList.iterator(); it.hasNext();)
{
JRCrosstabCell cell = (JRCrosstabCell) it.next();
String rowTotalGroup = cell.getRowTotalGroup();
if (rowTotalGroup != null && rowTotalGroup.equals(groupName))
{
it.remove();
cellsMap.remove(new Pair(rowTotalGroup, cell.getColumnTotalGroup()));
getEventSupport().fireCollectionElementRemovedEvent(PROPERTY_CELLS, cell, -1);
}
}
removeRowGroupVars(removed);
getEventSupport().fireCollectionElementRemovedEvent(PROPERTY_ROW_GROUPS, removed, idx.intValue());
}
return removed;
}
protected void removeRowGroupVars(JRCrosstabRowGroup rowGroup)
{
removeVariable(rowGroup.getVariable());
for (Iterator measureIt = measures.iterator(); measureIt.hasNext();)
{
JRCrosstabMeasure measure = (JRCrosstabMeasure) measureIt.next();
removeTotalVar(measure, rowGroup, null);
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
removeTotalVar(measure, rowGroup, colGroup);
}
}
}
/**
* Removes a row group.
*
* @param group the group to be removed
* @return the removed group
*/
public JRCrosstabRowGroup removeRowGroup(JRCrosstabRowGroup group)
{
return removeRowGroup(group.getName());
}
/**
* Removes a column group.
*
* @param groupName the group name
* @return the removed group
*/
public JRCrosstabColumnGroup removeColumnGroup(String groupName)
{
JRCrosstabColumnGroup removed = null;
Integer idx = (Integer) columnGroupsMap.remove(groupName);
if (idx != null)
{
removed = (JRCrosstabColumnGroup) columnGroups.remove(idx.intValue());
for (ListIterator it = columnGroups.listIterator(idx.intValue()); it.hasNext();)
{
JRCrosstabColumnGroup group = (JRCrosstabColumnGroup) it.next();
columnGroupsMap.put(group.getName(), new Integer(it.previousIndex()));
}
for (Iterator it = cellsList.iterator(); it.hasNext();)
{
JRCrosstabCell cell = (JRCrosstabCell) it.next();
String columnTotalGroup = cell.getColumnTotalGroup();
if (columnTotalGroup != null && columnTotalGroup.equals(groupName))
{
it.remove();
cellsMap.remove(new Pair(cell.getRowTotalGroup(), columnTotalGroup));
getEventSupport().fireCollectionElementRemovedEvent(PROPERTY_CELLS, cell, -1);
}
}
removeColGroupVars(removed);
getEventSupport().fireCollectionElementRemovedEvent(PROPERTY_COLUMN_GROUPS, removed, idx.intValue());
}
return removed;
}
protected void removeColGroupVars(JRCrosstabColumnGroup colGroup)
{
removeVariable(colGroup.getVariable());
for (Iterator measureIt = measures.iterator(); measureIt.hasNext();)
{
JRCrosstabMeasure measure = (JRCrosstabMeasure) measureIt.next();
removeTotalVar(measure, null, colGroup);
for (Iterator rowIt = rowGroups.iterator(); rowIt.hasNext();)
{
JRCrosstabRowGroup rowGroup = (JRCrosstabRowGroup) rowIt.next();
removeTotalVar(measure, rowGroup, colGroup);
}
}
}
/**
* Removes a column group.
*
* @param group the group
* @return the removed group
*/
public JRCrosstabColumnGroup removeColumnGroup(JRCrosstabColumnGroup group)
{
return removeColumnGroup(group.getName());
}
/**
* Removes a measure.
*
* @param measureName the measure name
* @return the removed measure
*/
public JRCrosstabMeasure removeMeasure(String measureName)
{
JRDesignCrosstabMeasure removed = null;
Integer idx = (Integer) measuresMap.remove(measureName);
if (idx != null)
{
removed = (JRDesignCrosstabMeasure) measures.remove(idx.intValue());
for (ListIterator it = measures.listIterator(idx.intValue()); it.hasNext();)
{
JRCrosstabMeasure group = (JRCrosstabMeasure) it.next();
measuresMap.put(group.getName(), new Integer(it.previousIndex()));
}
removeMeasureVars(removed);
removed.removePropertyChangeListener(JRDesignCrosstabMeasure.PROPERTY_VALUE_CLASS, measureClassChangeListener);
getEventSupport().fireCollectionElementRemovedEvent(PROPERTY_MEASURES, removed, idx.intValue());
}
return removed;
}
protected void removeMeasureVars(JRDesignCrosstabMeasure measure)
{
removeVariable(measure.getVariable());
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
removeTotalVar(measure, null, colGroup);
}
for (Iterator rowIt = rowGroups.iterator(); rowIt.hasNext();)
{
JRCrosstabRowGroup rowGroup = (JRCrosstabRowGroup) rowIt.next();
removeTotalVar(measure, rowGroup, null);
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
removeTotalVar(measure, rowGroup, colGroup);
}
}
}
/**
* Removes a measure.
*
* @param measure the measure
* @return the removed measure
*/
public JRCrosstabMeasure removeMeasure(JRCrosstabMeasure measure)
{
return removeMeasure(measure.getName());
}
public boolean isRepeatColumnHeaders()
{
return repeatColumnHeaders;
}
/**
* Sets the repeat column headers flag.
*
* @param repeatColumnHeaders whether to repeat the column headers on row breaks
* @see JRCrosstab#isRepeatColumnHeaders()
*/
public void setRepeatColumnHeaders(boolean repeatColumnHeaders)
{
boolean old = this.repeatColumnHeaders;
this.repeatColumnHeaders = repeatColumnHeaders;
getEventSupport().firePropertyChange(PROPERTY_REPEAT_COLUMN_HEADERS, old, this.repeatColumnHeaders);
}
public boolean isRepeatRowHeaders()
{
return repeatRowHeaders;
}
/**
* Sets the repeat row headers flag.
*
* @param repeatRowHeaders whether to repeat the row headers on column breaks
* @see JRCrosstab#isRepeatRowHeaders()
*/
public void setRepeatRowHeaders(boolean repeatRowHeaders)
{
boolean old = this.repeatRowHeaders;
this.repeatRowHeaders = repeatRowHeaders;
getEventSupport().firePropertyChange(PROPERTY_REPEAT_ROW_HEADERS, old, this.repeatRowHeaders);
}
public JRCrosstabCell[][] getCells()
{
return crossCells;
}
/**
* Returns the data cells list.
*
* @return the data cells list
* @see #addCell(JRDesignCrosstabCell)
*/
public List getCellsList()
{
return cellsList;
}
/**
* Returns the crosstab cells indexed by corresponding row total group/
* column total group {@link Pair pairs}.
*
* @return the crosstab cells indexed by row/column total groups
* @see JRCrosstabCell#getRowTotalGroup()
* @see JRCrosstabCell#getColumnTotalGroup()
*/
public Map getCellsMap()
{
return cellsMap;
}
/**
* Adds a data cell to the crosstab.
*
* @param cell the cell
* @throws JRException
* @see JRCrosstab#getCells()
*/
public void addCell(JRDesignCrosstabCell cell) throws JRException
{
String rowTotalGroup = cell.getRowTotalGroup();
if (rowTotalGroup != null && !rowGroupsMap.containsKey(rowTotalGroup))
{
throw new JRException("Row group " + rowTotalGroup + " does not exist.");
}
String columnTotalGroup = cell.getColumnTotalGroup();
if (columnTotalGroup != null && !columnGroupsMap.containsKey(columnTotalGroup))
{
throw new JRException("Row group " + columnTotalGroup + " does not exist.");
}
Object cellKey = new Pair(rowTotalGroup, columnTotalGroup);
if (cellsMap.containsKey(cellKey))
{
throw new JRException("Duplicate cell in crosstab.");
}
cellsMap.put(cellKey, cell);
cellsList.add(cell);
setCellOrigin(cell.getContents(),
new JRCrosstabOrigin(this, JRCrosstabOrigin.TYPE_DATA_CELL,
rowTotalGroup, columnTotalGroup));
getEventSupport().fireCollectionElementAddedEvent(PROPERTY_CELLS, cell, cellsList.size() - 1);
}
/**
* Removes a data cell.
*
* @param rowTotalGroup the cell's total row group
* @param columnTotalGroup the cell's total column group
* @return the removed cell
*/
public JRCrosstabCell removeCell(String rowTotalGroup, String columnTotalGroup)
{
Object cellKey = new Pair(rowTotalGroup, columnTotalGroup);
JRCrosstabCell cell = (JRCrosstabCell) cellsMap.remove(cellKey);
if (cell != null)
{
cellsList.remove(cell);
getEventSupport().fireCollectionElementRemovedEvent(PROPERTY_CELLS, cell, -1);
}
return cell;
}
/**
* Removes a data cell.
*
* @param cell the cell to be removed
* @return the removed cell
*/
public JRCrosstabCell removeCell(JRCrosstabCell cell)
{
return removeCell(cell.getRowTotalGroup(), cell.getColumnTotalGroup());
}
public JRCrosstabParameter[] getParameters()
{
JRCrosstabParameter[] parameters = new JRCrosstabParameter[parametersList.size()];
parametersList.toArray(parameters);
return parameters;
}
/**
* Returns the paremeters list.
*
* @return the paremeters list
*/
public List getParametersList()
{
return parametersList;
}
/**
* Returns the parameters indexed by names.
*
* @return the parameters indexed by names
*/
public Map getParametersMap()
{
return parametersMap;
}
public JRExpression getParametersMapExpression()
{
return parametersMapExpression;
}
/**
* Adds a parameter to the crosstab.
*
* @param parameter the parameter
* @throws JRException
* @see JRCrosstab#getMeasures()
*/
public void addParameter(JRCrosstabParameter parameter) throws JRException
{
if (parametersMap.containsKey(parameter.getName()))
{
if (parametersMap.containsKey(parameter.getName()))
{
throw new JRException("Duplicate declaration of parameter : " + parameter.getName());
}
}
parametersMap.put(parameter.getName(), parameter);
parametersList.add(parameter);
getEventSupport().fireCollectionElementAddedEvent(PROPERTY_PARAMETERS, parameter, parametersList.size() - 1);
}
/**
* Removes a parameter.
*
* @param parameterName the name of the parameter to be removed
* @return the removed parameter
*/
public JRCrosstabParameter removeParameter(String parameterName)
{
JRCrosstabParameter param = (JRCrosstabParameter) parametersMap.remove(parameterName);
if (param != null)
{
int idx = parametersList.indexOf(param);
if (idx >= 0)
{
parametersList.remove(idx);
}
getEventSupport().fireCollectionElementRemovedEvent(PROPERTY_PARAMETERS, param, idx);
}
return param;
}
/**
* Removes a parameter.
*
* @param parameter the parameter to be removed
* @return the removed parameter
*/
public JRCrosstabParameter removeParameter(JRCrosstabParameter parameter)
{
return removeParameter(parameter.getName());
}
/**
* Sets the parameters map expression.
*
* @param expression the parameters map expression
* @see JRCrosstab#getParametersMapExpression()
*/
public void setParametersMapExpression(JRExpression expression)
{
Object old = this.parametersMapExpression;
this.parametersMapExpression = expression;
getEventSupport().firePropertyChange(PROPERTY_PARAMETERS_MAP_EXPRESSION, old, this.parametersMapExpression);
}
/**
* Returns the variables of this crosstab indexed by name.
*
* @return the variables of this crosstab indexed by name
*/
public Map getVariablesMap()
{
JRVariable[] variables = getVariables();
Map variablesMap = new HashMap();
for (int i = 0; i < variables.length; i++)
{
variablesMap.put(variables[i].getName(), variables[i]);
}
return variablesMap;
}
/**
* Returns the list of variables created for this crosstab.
*
* @return the list of variables created for this crosstab
* @see JRCrosstabGroup#getVariable()
* @see JRCrosstabMeasure#getVariable()
* @see JRCrosstab#VARIABLE_ROW_COUNT
* @see JRCrosstab#VARIABLE_COLUMN_COUNT
*/
public JRVariable[] getVariables()
{
JRVariable[] variables = new JRVariable[variablesList.size()];
variablesList.values().toArray(variables);
return variables;
}
public int getColumnBreakOffset()
{
return columnBreakOffset;
}
/**
* Sets the column break offset.
*
* @param columnBreakOffset the offset
* @see JRCrosstab#getColumnBreakOffset()
*/
public void setColumnBreakOffset(int columnBreakOffset)
{
int old = this.columnBreakOffset;
this.columnBreakOffset = columnBreakOffset;
getEventSupport().firePropertyChange(PROPERTY_COLUMN_BREAK_OFFSET, old, this.columnBreakOffset);
}
/**
* Performs all the calculations required for report compilation.
*/
public void preprocess()
{
setGroupVariablesClass(rowGroups);
setGroupVariablesClass(columnGroups);
calculateSizes();
}
protected void setGroupVariablesClass(List groups)
{
for (Iterator it = groups.iterator(); it.hasNext();)
{
JRDesignCrosstabGroup group = (JRDesignCrosstabGroup) it.next();
JRCrosstabBucket bucket = group.getBucket();
if (bucket != null)
{
JRExpression expression = bucket.getExpression();
if (expression != null)
{
group.designVariable.setValueClassName(expression.getValueClassName());
}
}
}
}
protected void calculateSizes()
{
setWhenNoDataCellSize();
createCellMatrix();
int rowHeadersWidth = calculateRowHeadersSizes();
int colHeadersHeight = calculateColumnHeadersSizes();
if (headerCell != null)
{
headerCell.setWidth(rowHeadersWidth);
headerCell.setHeight(colHeadersHeight);
}
}
protected void setWhenNoDataCellSize()
{
if (whenNoDataCell != null)
{
whenNoDataCell.setWidth(getWidth());
whenNoDataCell.setHeight(getHeight());
}
}
protected void createCellMatrix()
{
crossCells = new JRDesignCrosstabCell[rowGroups.size() + 1][columnGroups.size() + 1];
for (Iterator it = cellsList.iterator(); it.hasNext();)
{
JRDesignCrosstabCell crosstabCell = (JRDesignCrosstabCell) it.next();
JRDesignCellContents contents = (JRDesignCellContents) crosstabCell.getContents();
String rowTotalGroup = crosstabCell.getRowTotalGroup();
int rowGroupIndex = rowTotalGroup == null ? rowGroupIndex = rowGroups.size() : ((Integer) rowGroupsMap.get(rowTotalGroup)).intValue();
Integer cellWidth = crosstabCell.getWidth();
if (cellWidth != null)
{
contents.setWidth(cellWidth.intValue());
}
String columnTotalGroup = crosstabCell.getColumnTotalGroup();
int columnGroupIndex = columnTotalGroup == null ? columnGroupIndex = columnGroups.size() : ((Integer) columnGroupsMap.get(columnTotalGroup)).intValue();
Integer cellHeight = crosstabCell.getHeight();
if (cellHeight != null)
{
contents.setHeight(cellHeight.intValue());
}
crossCells[rowGroupIndex][columnGroupIndex] = crosstabCell;
}
inheritCells();
}
protected JRDesignCrosstabRowGroup getRowGroup(int rowGroupIndex)
{
return (JRDesignCrosstabRowGroup) rowGroups.get(rowGroupIndex);
}
protected JRDesignCrosstabColumnGroup getColumnGroup(int columnGroupIndex)
{
return (JRDesignCrosstabColumnGroup) columnGroups.get(columnGroupIndex);
}
protected void inheritCells()
{
for (int i = rowGroups.size(); i >= 0 ; --i)
{
for (int j = columnGroups.size(); j >= 0 ; --j)
{
boolean used = (i == rowGroups.size() || getRowGroup(i).hasTotal()) &&
(j == columnGroups.size() || getColumnGroup(j).hasTotal());
if (used)
{
if (crossCells[i][j] == null)
{
inheritCell(i, j);
if (crossCells[i][j] == null)
{
crossCells[i][j] = emptyCell(i, j);
inheritCellSize(i, j);
}
}
else
{
inheritCellSize(i, j);
}
}
else
{
crossCells[i][j] = null;
}
}
}
}
private JRDesignCrosstabCell emptyCell(int i, int j)
{
JRDesignCrosstabCell emptyCell = new JRDesignCrosstabCell();
if (i < rowGroups.size())
{
emptyCell.setRowTotalGroup(((JRCrosstabRowGroup) rowGroups.get(i)).getName());
}
if (j < columnGroups.size())
{
emptyCell.setColumnTotalGroup(((JRCrosstabColumnGroup) columnGroups.get(j)).getName());
}
return emptyCell;
}
protected void inheritCellSize(int i, int j)
{
JRDesignCrosstabCell cell = crossCells[i][j];
JRDesignCellContents contents = (JRDesignCellContents) cell.getContents();
if (contents.getWidth() == JRCellContents.NOT_CALCULATED)
{
if (i < rowGroups.size())
{
JRDesignCrosstabCell rowCell = crossCells[rowGroups.size()][j];
if (rowCell != null)
{
contents.setWidth(rowCell.getContents().getWidth());
}
}
else
{
for (int k = j + 1; k <= columnGroups.size(); ++k)
{
if (crossCells[i][k] != null)
{
contents.setWidth(crossCells[i][k].getContents().getWidth());
break;
}
}
}
}
if (contents.getHeight() == JRCellContents.NOT_CALCULATED)
{
if (j < columnGroups.size())
{
JRDesignCrosstabCell colCell = crossCells[i][columnGroups.size()];
if (colCell != null)
{
contents.setHeight(colCell.getContents().getHeight());
}
}
else
{
for (int k = i + 1; k <= rowGroups.size(); ++k)
{
if (crossCells[k][j] != null)
{
contents.setHeight(crossCells[k][j].getContents().getHeight());
}
}
}
}
}
protected void inheritCell(int i, int j)
{
JRDesignCrosstabCell inheritedCell = null;
if (j < columnGroups.size())
{
JRDesignCrosstabCell colCell = crossCells[rowGroups.size()][j];
JRDesignCellContents colContents = colCell == null ? null : (JRDesignCellContents) colCell.getContents();
for (int k = j + 1; inheritedCell == null && k <= columnGroups.size(); ++k)
{
JRDesignCrosstabCell cell = crossCells[i][k];
if (cell != null)
{
JRDesignCellContents contents = (JRDesignCellContents) cell.getContents();
if (colContents == null || contents.getWidth() == colContents.getWidth())
{
inheritedCell = cell;
}
}
}
}
if (inheritedCell == null && i < rowGroups.size())
{
JRDesignCrosstabCell rowCell = crossCells[i][columnGroups.size()];
JRDesignCellContents rowContents = rowCell == null ? null : (JRDesignCellContents) rowCell.getContents();
for (int k = i + 1; inheritedCell == null && k <= rowGroups.size(); ++k)
{
JRDesignCrosstabCell cell = crossCells[k][j];
if (cell != null)
{
JRDesignCellContents contents = (JRDesignCellContents) cell.getContents();
if (rowContents == null || contents.getHeight() == rowContents.getHeight())
{
inheritedCell = cell;
}
}
}
}
crossCells[i][j] = inheritedCell;
}
protected int calculateRowHeadersSizes()
{
int widthSum = 0;
for (int i = rowGroups.size() - 1, heightSum = 0; i >= 0; --i)
{
JRDesignCrosstabRowGroup group = (JRDesignCrosstabRowGroup) rowGroups.get(i);
widthSum += group.getWidth();
JRDesignCrosstabCell cell = crossCells[i + 1][columnGroups.size()];
if (cell != null)
{
heightSum += cell.getContents().getHeight();
}
JRDesignCellContents header = (JRDesignCellContents) group.getHeader();
header.setHeight(heightSum);
header.setWidth(group.getWidth());
if (group.hasTotal())
{
JRDesignCellContents totalHeader = (JRDesignCellContents) group.getTotalHeader();
totalHeader.setWidth(widthSum);
JRDesignCrosstabCell totalCell = crossCells[i][columnGroups.size()];
if (totalCell != null)
{
totalHeader.setHeight(totalCell.getContents().getHeight());
}
}
}
return widthSum;
}
protected int calculateColumnHeadersSizes()
{
int heightSum = 0;
for (int i = columnGroups.size() - 1, widthSum = 0; i >= 0; --i)
{
JRDesignCrosstabColumnGroup group = (JRDesignCrosstabColumnGroup) columnGroups.get(i);
heightSum += group.getHeight();
JRDesignCrosstabCell cell = crossCells[rowGroups.size()][i + 1];
if (cell != null)
{
widthSum += cell.getContents().getWidth();
}
JRDesignCellContents header = (JRDesignCellContents) group.getHeader();
header.setHeight(group.getHeight());
header.setWidth(widthSum);
if (group.hasTotal())
{
JRDesignCellContents totalHeader = (JRDesignCellContents) group.getTotalHeader();
totalHeader.setHeight(heightSum);
JRDesignCrosstabCell totalCell = crossCells[rowGroups.size()][i];
if (totalCell != null)
{
totalHeader.setWidth(totalCell.getContents().getWidth());
}
}
}
return heightSum;
}
public JRCellContents getWhenNoDataCell()
{
return whenNoDataCell;
}
/**
* Sets the "No data" cell.
*
* @param whenNoDataCell the cell
* @see JRCrosstab#getWhenNoDataCell()
*/
public void setWhenNoDataCell(JRDesignCellContents whenNoDataCell)
{
Object old = this.whenNoDataCell;
this.whenNoDataCell = whenNoDataCell;
setCellOrigin(this.whenNoDataCell, new JRCrosstabOrigin(this, JRCrosstabOrigin.TYPE_WHEN_NO_DATA_CELL));
getEventSupport().firePropertyChange(PROPERTY_WHEN_NO_DATA_CELL, old, this.whenNoDataCell);
}
public JRElement getElementByKey(String elementKey)
{
return JRBaseCrosstab.getElementByKey(this, elementKey);
}
public byte getMode()
{
return JRStyleResolver.getMode(this, MODE_TRANSPARENT);
}
public JRCellContents getHeaderCell()
{
return headerCell;
}
/**
* Sets the crosstab header cell (this cell will be rendered at the upper-left corder of the crosstab).
*
* @param headerCell the cell
* @see JRCrosstab#getHeaderCell()
*/
public void setHeaderCell(JRDesignCellContents headerCell)
{
Object old = this.headerCell;
this.headerCell = headerCell;
setCellOrigin(this.headerCell, new JRCrosstabOrigin(this, JRCrosstabOrigin.TYPE_HEADER_CELL));
getEventSupport().firePropertyChange(PROPERTY_HEADER_CELL, old, this.headerCell);
}
protected void measureClassChanged(JRDesignCrosstabMeasure measure, String valueClassName)
{
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
setTotalVarClass(measure, null, colGroup, valueClassName);
}
for (Iterator rowIt = rowGroups.iterator(); rowIt.hasNext();)
{
JRCrosstabRowGroup rowGroup = (JRCrosstabRowGroup) rowIt.next();
setTotalVarClass(measure, rowGroup, null, valueClassName);
for (Iterator colIt = columnGroups.iterator(); colIt.hasNext();)
{
JRCrosstabColumnGroup colGroup = (JRCrosstabColumnGroup) colIt.next();
setTotalVarClass(measure, rowGroup, colGroup, valueClassName);
}
}
}
protected void setTotalVarClass(JRCrosstabMeasure measure, JRCrosstabRowGroup rowGroup, JRCrosstabColumnGroup colGroup, String valueClassName)
{
JRDesignVariable variable = getVariable(getTotalVariableName(measure, rowGroup, colGroup));
variable.setValueClassName(valueClassName);
}
private void addVariable(JRVariable variable)
{
variablesList.put(variable.getName(), variable);
}
private void removeVariable(JRVariable variable)
{
removeVariable(variable.getName());
}
private void removeVariable(String varName)
{
variablesList.remove(varName);
}
private JRDesignVariable getVariable(String varName)
{
return (JRDesignVariable) variablesList.get(varName);
}
public byte getRunDirection()
{
return runDirection;
}
public void setRunDirection(byte runDirection)
{
byte old = this.runDirection;
this.runDirection = runDirection;
getEventSupport().firePropertyChange(JRBaseCrosstab.PROPERTY_RUN_DIRECTION, old, this.runDirection);
}
protected void setCellOrigin(JRCellContents cell, JRCrosstabOrigin origin)
{
if (cell instanceof JRDesignCellContents)
{
setCellOrigin((JRDesignCellContents) cell, origin);
}
}
protected void setCellOrigin(JRDesignCellContents cell, JRCrosstabOrigin origin)
{
if (cell != null)
{
cell.setOrigin(origin);
}
}
protected void setParent(JRDesignCrosstabGroup group)
{
if (group != null)
{
group.setParent(this);
}
}
/**
*
*/
public Object clone()
{
JRDesignCrosstab clone = (JRDesignCrosstab)super.clone();
if (parametersList != null)
{
clone.parametersList = new ArrayList(parametersList.size());
clone.parametersMap = new HashMap(parametersList.size());
for(int i = 0; i < parametersList.size(); i++)
{
JRCrosstabParameter parameter =
(JRCrosstabParameter)((JRCrosstabParameter)parametersList.get(i)).clone();
clone.parametersList.add(parameter);
clone.parametersMap.put(parameter.getName(), parameter);
}
}
if (variablesList != null)
{
clone.variablesList = new SequencedHashMap(variablesList.size());
for(Iterator it = variablesList.sequence().iterator(); it.hasNext();)
{
Object key = it.next();
JRVariable variable = (JRVariable)variablesList.get(key);
clone.variablesList.put(variable.getName(), variable);
}
}
if (parametersMapExpression != null)
{
clone.parametersMapExpression = (JRExpression)parametersMapExpression.clone();
}
if (dataset != null)
{
clone.dataset = (JRDesignCrosstabDataset)dataset.clone();
}
if (rowGroups != null)
{
clone.rowGroups = new ArrayList(rowGroups.size());
clone.rowGroupsMap = new HashMap(rowGroups.size());
for(int i = 0; i < rowGroups.size(); i++)
{
JRCrosstabRowGroup group =
(JRCrosstabRowGroup)((JRCrosstabRowGroup)rowGroups.get(i)).clone();
clone.rowGroups.add(group);
clone.rowGroupsMap.put(group.getName(), new Integer(i));
}
}
if (columnGroups != null)
{
clone.columnGroups = new ArrayList(columnGroups.size());
clone.columnGroupsMap = new HashMap(columnGroups.size());
for(int i = 0; i < columnGroups.size(); i++)
{
JRCrosstabColumnGroup group =
(JRCrosstabColumnGroup)((JRCrosstabColumnGroup)columnGroups.get(i)).clone();
clone.columnGroups.add(group);
clone.columnGroupsMap.put(group.getName(), new Integer(i));
}
}
if (measures != null)
{
clone.measures = new ArrayList(measures.size());
clone.measuresMap = new HashMap(measures.size());
for(int i = 0; i < measures.size(); i++)
{
JRCrosstabMeasure measure =
(JRCrosstabMeasure)((JRCrosstabMeasure)measures.get(i)).clone();
clone.measures.add(measure);
clone.measuresMap.put(measure.getName(), new Integer(i));
}
}
if (cellsList != null)
{
clone.cellsList = new ArrayList(cellsList.size());
clone.cellsMap = new HashMap(cellsList.size());
for(int i = 0; i < cellsList.size(); i++)
{
JRDesignCrosstabCell cell =
(JRDesignCrosstabCell)((JRDesignCrosstabCell)cellsList.get(i)).clone();
clone.cellsList.add(cell);
clone.cellsMap.put(new Pair(cell.getRowTotalGroup(), cell.getColumnTotalGroup()), cell);
}
}
if (whenNoDataCell != null)
{
clone.whenNoDataCell = (JRDesignCellContents)whenNoDataCell.clone();
}
if (headerCell != null)
{
clone.headerCell = (JRDesignCellContents)headerCell.clone();
}
return clone;
}
public List getRowGroupsList()
{
return rowGroups;
}
public Map getRowGroupIndicesMap()
{
return rowGroupsMap;
}
public List getColumnGroupsList()
{
return columnGroups;
}
public Map getColumnGroupIndicesMap()
{
return columnGroupsMap;
}
public List getMesuresList()
{
return measures;
}
public Map getMeasureIndicesMap()
{
return measuresMap;
}
}
The table below shows all metrics for JRDesignCrosstab.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 200.00 | Number of blocks | |
| BLOCK_COMMENT | 27.00 | Number of block comment lines | |
| COMMENTS | 239.00 | Comment lines | |
| COMMENT_DENSITY | 0.35 | Comment density | |
| COMPARISONS | 136.00 | Number of comparison operators | |
| CYCLOMATIC | 214.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 37.00 | Comments in declarations | |
| DOC_COMMENT | 211.00 | Number of javadoc comment lines | |
| ELOC | 674.00 | Effective lines of code | |
| EXEC_COMMENTS | 1.00 | Comments in executable code | |
| EXITS | 133.00 | Procedure exits | |
| FUNCTIONS | 91.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 116.69 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 166.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 0.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 0.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 0.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 1.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 1.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 0.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 0.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 0.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 0.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 0.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 0.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 1.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 1.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 0.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 2.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 0.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 0.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 12.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 31.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 4.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 0.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 1.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 0.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 1.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 0.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 4.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 2860.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 0.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 0.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 0.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 0.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 2.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 0.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 1.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 20.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 6.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 1.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 0.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 1572.00 | Number of lines in the source file | |
| LINE_COMMENT | 1.00 | Number of line comments | |
| LOC | 1078.00 | Lines of code | |
| LOGICAL_LINES | 530.00 | Number of statements | |
| LOOPS | 41.00 | Number of loops | |
| NEST_DEPTH | 6.00 | Maximum nesting depth | |
| OPERANDS | 2406.00 | Number of operands | |
| OPERATORS | 4559.00 | Number of operators | |
| PARAMS | 68.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 6965.00 | Halstead program length | |
| PROGRAM_VOCAB | 622.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 98.00 | Number of return points from functions | |
| SIZE | 42434.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 567.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 55.00 | Number of unique operators | |
| WHITESPACE | 255.00 | Number of whitespace lines | |