NamingConventions.java
| Index Score | ||
|---|---|---|
 |
 |
net.sourceforge.phpdt.core |
 |
 |
PHPeclipse |
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 | |
|---|---|---|
| DOC_COMMENT | Number of javadoc comment lines |  |
| COMMENTS | Comment lines | |
| SIZE | Size of the file in bytes | |
| PARAMS | Number of formal parameter declarations | |
| LINES | Number of lines in the source file | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| OPERATORS | Number of operators | |
| PROGRAM_LENGTH | Halstead program length | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| ELOC | Effective lines of code | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
| OPERANDS | Number of operands | |
| LOC | Lines of code | |
| DECL_COMMENTS | Comments in declarations | |
| CYCLOMATIC | Cyclomatic complexity | |
| BLOCKS | Number of blocks | |
| JAVA0270 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| UNIQUE_OPERANDS | Number of unique operands | |
| NEST_DEPTH | Maximum nesting depth | |
| PROGRAM_VOLUME | Halstead program volume | |
| LOGICAL_LINES | Number of statements | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0138 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| EXEC_COMMENTS | Comments in executable code | |
| UNIQUE_OPERATORS | Number of unique operators | |
| FUNCTIONS | Number of function declarations | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0100 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| LINE_COMMENT | Number of line comments | |
| JAVA0068 | JAVA0068 Modifiers not declared in recommended order | |
/*******************************************************************************
* Copyright (c) 2000, 2004 IBM Corporation and others.
* 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
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package net.sourceforge.phpdt.core;
import net.sourceforge.phpdt.core.compiler.CharOperation;
import net.sourceforge.phpdt.internal.codeassist.impl.AssistOptions;
import net.sourceforge.phpdt.internal.core.INamingRequestor;
import net.sourceforge.phpdt.internal.core.InternalNamingConventions;
/**
* Provides methods for computing Java-specific names.
* <p>
* The behavior of the methods is dependent of several JavaCore options.
* <p>
* The possible options are :
* <ul>
* <li>CODEASSIST_FIELD_PREFIXES : Define the Prefixes for Field Name.</li>
* <li>CODEASSIST_STATIC_FIELD_PREFIXES : Define the Prefixes for Static Field
* Name.</li>
* <li>CODEASSIST_LOCAL_PREFIXES : Define the Prefixes for Local Variable Name.</li>
* <li>CODEASSIST_ARGUMENT_PREFIXES : Define the Prefixes for Argument Name.</li>
* <li>CODEASSIST_FIELD_SUFFIXES : Define the Suffixes for Field Name.</li>
* <li>CODEASSIST_STATIC_FIELD_SUFFIXES : Define the Suffixes for Static Field
* Name.</li>
* <li>CODEASSIST_LOCAL_SUFFIXES : Define the Suffixes for Local Variable Name.</li>
* <li>CODEASSIST_ARGUMENT_SUFFIXES : Define the Suffixes for Argument Name.</li>
* </ul>
* </p>
* <p>
* For a complete description of the configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these options,
* see <code>JavaCore#setOptions()</code>.
* </p>
* <p>
* This class provides static methods and constants only; it is not intended to
* be instantiated or subclassed by clients.
* </p>
*
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
* @since 2.1
*/
public final class NamingConventions {
private static final char[] GETTER_BOOL_NAME = "is".toCharArray(); //$NON-NLS-1$
private static final char[] GETTER_NAME = "get".toCharArray(); //$NON-NLS-1$
private static final char[] SETTER_NAME = "set".toCharArray(); //$NON-NLS-1$
private static class NamingRequestor implements INamingRequestor {
private final static int SIZE = 10;
// for acceptNameWithPrefixAndSuffix
private char[][] firstPrefixAndFirstSuffixResults = new char[SIZE][];
private int firstPrefixAndFirstSuffixResultsCount = 0;
private char[][] firstPrefixAndSuffixResults = new char[SIZE][];
private int firstPrefixAndSuffixResultsCount = 0;
private char[][] prefixAndFirstSuffixResults = new char[SIZE][];
private int prefixAndFirstSuffixResultsCount = 0;
private char[][] prefixAndSuffixResults = new char[SIZE][];
private int prefixAndSuffixResultsCount = 0;
// for acceptNameWithPrefix
private char[][] firstPrefixResults = new char[SIZE][];
private int firstPrefixResultsCount = 0;
private char[][] prefixResults = new char[SIZE][];
private int prefixResultsCount = 0;
// for acceptNameWithSuffix
private char[][] firstSuffixResults = new char[SIZE][];
private int firstSuffixResultsCount = 0;
private char[][] suffixResults = new char[SIZE][];
private int suffixResultsCount = 0;
// for acceptNameWithoutPrefixAndSuffix
private char[][] otherResults = new char[SIZE][];
private int otherResultsCount = 0;
public void acceptNameWithPrefixAndSuffix(char[] name,
boolean isFirstPrefix, boolean isFirstSuffix) {
if (isFirstPrefix && isFirstSuffix) {
int length = this.firstPrefixAndFirstSuffixResults.length;
if (length == this.firstPrefixAndFirstSuffixResultsCount) {
System
.arraycopy(
this.firstPrefixAndFirstSuffixResults,
0,
this.firstPrefixAndFirstSuffixResults = new char[length * 2][],
0, length);
}
this.firstPrefixAndFirstSuffixResults[this.firstPrefixAndFirstSuffixResultsCount++] = name;
} else if (isFirstPrefix) {
int length = this.firstPrefixAndSuffixResults.length;
if (length == this.firstPrefixAndSuffixResultsCount) {
System
.arraycopy(
this.firstPrefixAndSuffixResults,
0,
this.firstPrefixAndSuffixResults = new char[length * 2][],
0, length);
}
this.firstPrefixAndSuffixResults[this.firstPrefixAndSuffixResultsCount++] = name;
} else if (isFirstSuffix) {
int length = this.prefixAndFirstSuffixResults.length;
if (length == this.prefixAndFirstSuffixResultsCount) {
System
.arraycopy(
this.prefixAndFirstSuffixResults,
0,
this.prefixAndFirstSuffixResults = new char[length * 2][],
0, length);
}
this.prefixAndFirstSuffixResults[this.prefixAndFirstSuffixResultsCount++] = name;
} else {
int length = this.prefixAndSuffixResults.length;
if (length == this.prefixAndSuffixResultsCount) {
System
.arraycopy(
this.prefixAndSuffixResults,
0,
this.prefixAndSuffixResults = new char[length * 2][],
0, length);
}
this.prefixAndSuffixResults[this.prefixAndSuffixResultsCount++] = name;
}
}
public void acceptNameWithPrefix(char[] name, boolean isFirstPrefix) {
if (isFirstPrefix) {
int length = this.firstPrefixResults.length;
if (length == this.firstPrefixResultsCount) {
System.arraycopy(this.firstPrefixResults, 0,
this.firstPrefixResults = new char[length * 2][],
0, length);
}
this.firstPrefixResults[this.firstPrefixResultsCount++] = name;
} else {
int length = this.prefixResults.length;
if (length == this.prefixResultsCount) {
System.arraycopy(this.prefixResults, 0,
this.prefixResults = new char[length * 2][], 0,
length);
}
this.prefixResults[this.prefixResultsCount++] = name;
}
}
public void acceptNameWithSuffix(char[] name, boolean isFirstSuffix) {
if (isFirstSuffix) {
int length = this.firstSuffixResults.length;
if (length == this.firstSuffixResultsCount) {
System.arraycopy(this.firstSuffixResults, 0,
this.firstSuffixResults = new char[length * 2][],
0, length);
}
this.firstSuffixResults[this.firstSuffixResultsCount++] = name;
} else {
int length = this.suffixResults.length;
if (length == this.suffixResultsCount) {
System.arraycopy(this.suffixResults, 0,
this.suffixResults = new char[length * 2][], 0,
length);
}
this.suffixResults[this.suffixResultsCount++] = name;
}
}
public void acceptNameWithoutPrefixAndSuffix(char[] name) {
int length = this.otherResults.length;
if (length == this.otherResultsCount) {
System.arraycopy(this.otherResults, 0,
this.otherResults = new char[length * 2][], 0, length);
}
this.otherResults[this.otherResultsCount++] = name;
}
public char[][] getResults() {
int count = this.firstPrefixAndFirstSuffixResultsCount
+ this.firstPrefixAndSuffixResultsCount
+ this.prefixAndFirstSuffixResultsCount
+ this.prefixAndSuffixResultsCount
+ this.firstPrefixResultsCount + this.prefixResultsCount
+ this.firstSuffixResultsCount + this.suffixResultsCount
+ this.otherResultsCount;
char[][] results = new char[count][];
int index = 0;
System.arraycopy(this.firstPrefixAndFirstSuffixResults, 0, results,
index, this.firstPrefixAndFirstSuffixResultsCount);
index += this.firstPrefixAndFirstSuffixResultsCount;
System.arraycopy(this.firstPrefixAndSuffixResults, 0, results,
index, this.firstPrefixAndSuffixResultsCount);
index += this.firstPrefixAndSuffixResultsCount;
System.arraycopy(this.prefixAndFirstSuffixResults, 0, results,
index, this.prefixAndFirstSuffixResultsCount);
index += this.prefixAndFirstSuffixResultsCount;
System.arraycopy(this.prefixAndSuffixResults, 0, results, index,
this.prefixAndSuffixResultsCount);
index += this.prefixAndSuffixResultsCount;
System.arraycopy(this.firstPrefixResults, 0, results, index,
this.firstPrefixResultsCount);
index += this.firstPrefixResultsCount;
System.arraycopy(this.prefixResults, 0, results, index,
this.prefixResultsCount);
index += this.prefixResultsCount;
System.arraycopy(this.firstSuffixResults, 0, results, index,
this.firstSuffixResultsCount);
index += this.firstSuffixResultsCount;
System.arraycopy(this.suffixResults, 0, results, index,
this.suffixResultsCount);
index += this.suffixResultsCount;
System.arraycopy(this.otherResults, 0, results, index,
this.otherResultsCount);
return results;
}
}
private NamingConventions() {
// Not instantiable
}
private static char[] removePrefixAndSuffix(char[] name, char[][] prefixes,
char[][] suffixes) {
// remove longer prefix
char[] withoutPrefixName = name;
if (prefixes != null) {
int bestLength = 0;
for (int i = 0; i < prefixes.length; i++) {
char[] prefix = prefixes[i];
if (CharOperation.prefixEquals(prefix, name)) {
int currLen = prefix.length;
boolean lastCharIsLetter = Character
.isLetter(prefix[currLen - 1]);
if (!lastCharIsLetter
|| (lastCharIsLetter && name.length > currLen && Character
.isUpperCase(name[currLen]))) {
if (bestLength < currLen && name.length != currLen) {
withoutPrefixName = CharOperation.subarray(name,
currLen, name.length);
bestLength = currLen;
}
}
}
}
}
// remove longer suffix
char[] withoutSuffixName = withoutPrefixName;
if (suffixes != null) {
int bestLength = 0;
for (int i = 0; i < suffixes.length; i++) {
char[] suffix = suffixes[i];
if (CharOperation.endsWith(withoutPrefixName, suffix)) {
int currLen = suffix.length;
if (bestLength < currLen
&& withoutPrefixName.length != currLen) {
withoutSuffixName = CharOperation.subarray(
withoutPrefixName, 0, withoutPrefixName.length
- currLen);
bestLength = currLen;
}
}
}
}
withoutSuffixName[0] = Character.toLowerCase(withoutSuffixName[0]);
return withoutSuffixName;
}
/**
* Remove prefix and suffix from an argument name.
* <p>
* If argument name prefix is <code>pre</code> and argument name suffix is
* <code>suf</code> then for an argument named <code>preArgsuf</code>
* the result of this method is <code>arg</code>. If there is no prefix
* or suffix defined in JavaCore options the result is the unchanged name
* <code>preArgsuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_ARGUMENT_PREFIXES and CODEASSIST_ARGUMENT_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the argument.
* @param argumentName
* argument's name.
* @return char[] the name without prefix and suffix.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[] removePrefixAndSuffixForArgumentName(
IJavaProject javaProject, char[] argumentName) {
AssistOptions assistOptions = new AssistOptions(javaProject
.getOptions(true));
return removePrefixAndSuffix(argumentName,
assistOptions.argumentPrefixes, assistOptions.argumentSuffixes);
}
/**
* Remove prefix and suffix from an argument name.
* <p>
* If argument name prefix is <code>pre</code> and argument name suffix is
* <code>suf</code> then for an argument named <code>preArgsuf</code>
* the result of this method is <code>arg</code>. If there is no prefix
* or suffix defined in JavaCore options the result is the unchanged name
* <code>preArgsuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_ARGUMENT_PREFIXES and CODEASSIST_ARGUMENT_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the argument.
* @param argumentName
* argument's name.
* @return char[] the name without prefix and suffix.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String removePrefixAndSuffixForArgumentName(
IJavaProject javaProject, String argumentName) {
return String.valueOf(removePrefixAndSuffixForArgumentName(javaProject,
argumentName.toCharArray()));
}
/**
* Remove prefix and suffix from a field name.
* <p>
* If field name prefix is <code>pre</code> and field name suffix is
* <code>suf</code> then for a field named <code>preFieldsuf</code> the
* result of this method is <code>field</code>. If there is no prefix or
* suffix defined in JavaCore options the result is the unchanged name
* <code>preFieldsuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES for instance field
* and CODEASSIST_STATIC_FIELD_PREFIXES, CODEASSIST_STATIC_FIELD_SUFFIXES
* for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the field.
* @param fieldName
* field's name.
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @return char[] the name without prefix and suffix.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[] removePrefixAndSuffixForFieldName(
IJavaProject javaProject, char[] fieldName, int modifiers) {
boolean isStatic = Flags.isStatic(modifiers);
AssistOptions assistOptions = new AssistOptions(javaProject
.getOptions(true));
return removePrefixAndSuffix(fieldName,
isStatic ? assistOptions.staticFieldPrefixes
: assistOptions.fieldPrefixes,
isStatic ? assistOptions.staticFieldSuffixes
: assistOptions.fieldSuffixes);
}
/**
* Remove prefix and suffix from a field name.
* <p>
* If field name prefix is <code>pre</code> and field name suffix is
* <code>suf</code> then for a field named <code>preFieldsuf</code> the
* result of this method is <code>field</code>. If there is no prefix or
* suffix defined in JavaCore options the result is the unchanged name
* <code>preFieldsuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES for instance field
* and CODEASSIST_STATIC_FIELD_PREFIXES, CODEASSIST_STATIC_FIELD_SUFFIXES
* for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the field.
* @param fieldName
* field's name.
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @return char[] the name without prefix and suffix.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String removePrefixAndSuffixForFieldName(
IJavaProject javaProject, String fieldName, int modifiers) {
return String.valueOf(removePrefixAndSuffixForFieldName(javaProject,
fieldName.toCharArray(), modifiers));
}
/**
* Remove prefix and suffix from a local variable name.
* <p>
* If local variable name prefix is <code>pre</code> and local variable
* name suffix is <code>suf</code> then for a local variable named
* <code>preLocalsuf</code> the result of this method is
* <code>local</code>. If there is no prefix or suffix defined in
* JavaCore options the result is the unchanged name
* <code>preLocalsuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_LOCAL_PREFIXES and CODEASSIST_LOCAL_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the variable.
* @param localName
* variable's name.
* @return char[] the name without prefix and suffix.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[] removePrefixAndSuffixForLocalVariableName(
IJavaProject javaProject, char[] localName) {
AssistOptions assistOptions = new AssistOptions(javaProject
.getOptions(true));
return removePrefixAndSuffix(localName, assistOptions.argumentPrefixes,
assistOptions.argumentSuffixes);
}
/**
* Remove prefix and suffix from a local variable name.
* <p>
* If local variable name prefix is <code>pre</code> and local variable
* name suffix is <code>suf</code> then for a local variable named
* <code>preLocalsuf</code> the result of this method is
* <code>local</code>. If there is no prefix or suffix defined in
* JavaCore options the result is the unchanged name
* <code>preLocalsuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_LOCAL_PREFIXES and CODEASSIST_LOCAL_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the variable.
* @param localName
* variable's name.
* @return char[] the name without prefix and suffix.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String removePrefixAndSuffixForLocalVariableName(
IJavaProject javaProject, String localName) {
return String.valueOf(removePrefixAndSuffixForLocalVariableName(
javaProject, localName.toCharArray()));
}
/**
* Suggest names for an argument. The name is computed from argument's type
* and possible prefixes or suffixes are added.
* <p>
* If the type of the argument is <code>TypeName</code>, the prefix for
* argument is <code>pre</code> and the suffix for argument is
* <code>suf</code> then the proposed names are
* <code>preTypeNamesuf</code> and <code>preNamesuf</code>. If there is
* no prefix or suffix the proposals are <code>typeName</code> and
* <code>name</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_ARGUMENT_PREFIXES and CODEASSIST_ARGUMENT_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the argument.
* @param packageName
* package of the argument's type.
* @param qualifiedTypeName
* argument's type.
* @param dim
* argument's dimension (0 if the argument is not an array).
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[][] an array of names.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[][] suggestArgumentNames(IJavaProject javaProject,
char[] packageName, char[] qualifiedTypeName, int dim,
char[][] excludedNames) {
NamingRequestor requestor = new NamingRequestor();
InternalNamingConventions.suggestArgumentNames(javaProject,
packageName, qualifiedTypeName, dim, excludedNames, requestor);
return requestor.getResults();
}
/**
* Suggest names for an argument. The name is computed from argument's type
* and possible prefixes or suffixes are added.
* <p>
* If the type of the argument is <code>TypeName</code>, the prefix for
* argument is <code>pre</code> and the suffix for argument is
* <code>suf</code> then the proposed names are
* <code>preTypeNamesuf</code> and <code>preNamesuf</code>. If there is
* no prefix or suffix the proposals are <code>typeName</code> and
* <code>name</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_ARGUMENT_PREFIXES and CODEASSIST_ARGUMENT_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the argument.
* @param packageName
* package of the argument's type.
* @param qualifiedTypeName
* argument's type.
* @param dim
* argument's dimension (0 if the argument is not an array).
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[][] an array of names.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String[] suggestArgumentNames(IJavaProject javaProject,
String packageName, String qualifiedTypeName, int dim,
String[] excludedNames) {
return convertCharsToString(suggestArgumentNames(javaProject,
packageName.toCharArray(), qualifiedTypeName.toCharArray(),
dim, convertStringToChars(excludedNames)));
}
/**
* Suggest names for a field. The name is computed from field's type and
* possible prefixes or suffixes are added.
* <p>
* If the type of the field is <code>TypeName</code>, the prefix for
* field is <code>pre</code> and the suffix for field is <code>suf</code>
* then the proposed names are <code>preTypeNamesuf</code> and
* <code>preNamesuf</code>. If there is no prefix or suffix the proposals
* are <code>typeName</code> and <code>name</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES and for instance
* field and CODEASSIST_STATIC_FIELD_PREFIXES,
* CODEASSIST_STATIC_FIELD_SUFFIXES for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the field.
* @param packageName
* package of the field's type.
* @param qualifiedTypeName
* field's type.
* @param dim
* field's dimension (0 if the field is not an array).
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[][] an array of names.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[][] suggestFieldNames(IJavaProject javaProject,
char[] packageName, char[] qualifiedTypeName, int dim,
int modifiers, char[][] excludedNames) {
NamingRequestor requestor = new NamingRequestor();
InternalNamingConventions.suggestFieldNames(javaProject, packageName,
qualifiedTypeName, dim, modifiers, excludedNames, requestor);
return requestor.getResults();
}
/**
* Suggest names for a field. The name is computed from field's type and
* possible prefixes or suffixes are added.
* <p>
* If the type of the field is <code>TypeName</code>, the prefix for
* field is <code>pre</code> and the suffix for field is <code>suf</code>
* then the proposed names are <code>preTypeNamesuf</code> and
* <code>preNamesuf</code>. If there is no prefix or suffix the proposals
* are <code>typeName</code> and <code>name</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES and for instance
* field and CODEASSIST_STATIC_FIELD_PREFIXES,
* CODEASSIST_STATIC_FIELD_SUFFIXES for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the field.
* @param packageName
* package of the field's type.
* @param qualifiedTypeName
* field's type.
* @param dim
* field's dimension (0 if the field is not an array).
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[][] an array of names.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String[] suggestFieldNames(IJavaProject javaProject,
String packageName, String qualifiedTypeName, int dim,
int modifiers, String[] excludedNames) {
return convertCharsToString(suggestFieldNames(javaProject, packageName
.toCharArray(), qualifiedTypeName.toCharArray(), dim,
modifiers, convertStringToChars(excludedNames)));
}
/**
* Suggest names for a local variable. The name is computed from variable's
* type and possible prefixes or suffixes are added.
* <p>
* If the type of the local variable is <code>TypeName</code>, the prefix
* for local variable is <code>pre</code> and the suffix for local
* variable is <code>suf</code> then the proposed names are
* <code>preTypeNamesuf</code> and <code>preNamesuf</code>. If there is
* no prefix or suffix the proposals are <code>typeName</code> and
* <code>name</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_LOCAL_PREFIXES and CODEASSIST_LOCAL_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the variable.
* @param packageName
* package of the variable's type.
* @param qualifiedTypeName
* variable's type.
* @param dim
* variable's dimension (0 if the variable is not an array).
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[][] an array of names.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[][] suggestLocalVariableNames(IJavaProject javaProject,
char[] packageName, char[] qualifiedTypeName, int dim,
char[][] excludedNames) {
NamingRequestor requestor = new NamingRequestor();
InternalNamingConventions.suggestLocalVariableNames(javaProject,
packageName, qualifiedTypeName, dim, excludedNames, requestor);
return requestor.getResults();
}
/**
* Suggest names for a local variable. The name is computed from variable's
* type and possible prefixes or suffixes are added.
* <p>
* If the type of the local variable is <code>TypeName</code>, the prefix
* for local variable is <code>pre</code> and the suffix for local
* variable is <code>suf</code> then the proposed names are
* <code>preTypeNamesuf</code> and <code>preNamesuf</code>. If there is
* no prefix or suffix the proposals are <code>typeName</code> and
* <code>name</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_LOCAL_PREFIXES and CODEASSIST_LOCAL_SUFFIXES.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param javaProject
* project which contains the variable.
* @param packageName
* package of the variable's type.
* @param qualifiedTypeName
* variable's type.
* @param dim
* variable's dimension (0 if the variable is not an array).
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[][] an array of names.
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String[] suggestLocalVariableNames(IJavaProject javaProject,
String packageName, String qualifiedTypeName, int dim,
String[] excludedNames) {
return convertCharsToString(suggestLocalVariableNames(javaProject,
packageName.toCharArray(), qualifiedTypeName.toCharArray(),
dim, convertStringToChars(excludedNames)));
}
/**
* Suggest name for a getter method. The name is computed from field's name
* and possible prefixes or suffixes are removed.
* <p>
* If the field name is <code>preFieldNamesuf</code> and the prefix for
* field is <code>pre</code> and the suffix for field is <code>suf</code>
* then the prosposed name is <code>isFieldName</code> for boolean field
* or <code>getFieldName</code> for others. If there is no prefix and
* suffix the proposal is <code>isPreFieldNamesuf</code> for boolean field
* or <code>getPreFieldNamesuf</code> for others.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES for instance field
* and CODEASSIST_STATIC_FIELD_PREFIXES, CODEASSIST_STATIC_FIELD_SUFFIXES
* for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param project
* project which contains the field.
* @param fieldName
* field's name's.
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @param isBoolean
* <code>true</code> if the field's type is boolean
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[] a name.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[] suggestGetterName(IJavaProject project,
char[] fieldName, int modifiers, boolean isBoolean,
char[][] excludedNames) {
if (isBoolean) {
char[] name = removePrefixAndSuffixForFieldName(project, fieldName,
modifiers);
int prefixLen = GETTER_BOOL_NAME.length;
if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)
&& name.length > prefixLen
&& Character.isUpperCase(name[prefixLen])) {
return suggestNewName(name, excludedNames);
} else {
return suggestNewName(CharOperation.concat(GETTER_BOOL_NAME,
suggestAccessorName(project, fieldName, modifiers)),
excludedNames);
}
} else {
return suggestNewName(CharOperation.concat(GETTER_NAME,
suggestAccessorName(project, fieldName, modifiers)),
excludedNames);
}
}
/**
* Suggest name for a getter method. The name is computed from field's name
* and possible prefixes or suffixes are removed.
* <p>
* If the field name is <code>preFieldNamesuf</code> and the prefix for
* field is <code>pre</code> and the suffix for field is <code>suf</code>
* then the prosposed name is <code>isFieldName</code> for boolean field
* or <code>getFieldName</code> for others. If there is no prefix and
* suffix the proposal is <code>isPreFieldNamesuf</code> for boolean field
* or <code>getPreFieldNamesuf</code> for others.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES for instance field
* and CODEASSIST_STATIC_FIELD_PREFIXES, CODEASSIST_STATIC_FIELD_SUFFIXES
* for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param project
* project which contains the field.
* @param fieldName
* field's name's.
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @param isBoolean
* <code>true</code> if the field's type is boolean
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[] a name.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String suggestGetterName(IJavaProject project,
String fieldName, int modifiers, boolean isBoolean,
String[] excludedNames) {
return String.valueOf(suggestGetterName(project, fieldName
.toCharArray(), modifiers, isBoolean,
convertStringToChars(excludedNames)));
}
/**
* Suggest name for a setter method. The name is computed from field's name
* and possible prefixes or suffixes are removed.
* <p>
* If the field name is <code>preFieldNamesuf</code> and the prefix for
* field is <code>pre</code> and the suffix for field is <code>suf</code>
* then the proposed name is <code>setFieldName</code>. If there is no
* prefix and suffix the proposal is <code>setPreFieldNamesuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES for instance field
* and CODEASSIST_STATIC_FIELD_PREFIXES, CODEASSIST_STATIC_FIELD_SUFFIXES
* for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param project
* project which contains the field.
* @param fieldName
* field's name's.
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @param isBoolean
* <code>true</code> if the field's type is boolean
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[] a name.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static char[] suggestSetterName(IJavaProject project,
char[] fieldName, int modifiers, boolean isBoolean,
char[][] excludedNames) {
if (isBoolean) {
char[] name = removePrefixAndSuffixForFieldName(project, fieldName,
modifiers);
int prefixLen = GETTER_BOOL_NAME.length;
if (CharOperation.prefixEquals(GETTER_BOOL_NAME, name)
&& name.length > prefixLen
&& Character.isUpperCase(name[prefixLen])) {
name = CharOperation.subarray(name, prefixLen, name.length);
return suggestNewName(CharOperation.concat(SETTER_NAME,
suggestAccessorName(project, name, modifiers)),
excludedNames);
} else {
return suggestNewName(CharOperation.concat(SETTER_NAME,
suggestAccessorName(project, fieldName, modifiers)),
excludedNames);
}
} else {
return suggestNewName(CharOperation.concat(SETTER_NAME,
suggestAccessorName(project, fieldName, modifiers)),
excludedNames);
}
}
/**
* Suggest name for a setter method. The name is computed from field's name
* and possible prefixes or suffixes are removed.
* <p>
* If the field name is <code>preFieldNamesuf</code> and the prefix for
* field is <code>pre</code> and the suffix for field is <code>suf</code>
* then the proposed name is <code>setFieldName</code>. If there is no
* prefix and suffix the proposal is <code>setPreFieldNamesuf</code>.
* </p>
* <p>
* This method is affected by the following JavaCore options :
* CODEASSIST_FIELD_PREFIXES, CODEASSIST_FIELD_SUFFIXES for instance field
* and CODEASSIST_STATIC_FIELD_PREFIXES, CODEASSIST_STATIC_FIELD_SUFFIXES
* for static field.
* </p>
* <p>
* For a complete description of these configurable options, see
* <code>getDefaultOptions</code>. For programmaticaly change these
* options, see <code>JavaCore#setOptions()</code>.
* </p>
*
* @param project
* project which contains the field.
* @param fieldName
* field's name's.
* @param modifiers
* field's modifiers as defined by the class <code>Flags</code>.
* @param isBoolean
* <code>true</code> if the field's type is boolean
* @param excludedNames
* a list of names which cannot be suggested (already used
* names). Can be <code>null</code> if there is no excluded
* names.
* @return char[] a name.
* @see Flags
* @see JavaCore#setOptions(java.util.Hashtable)
* @see JavaCore#getDefaultOptions()
*/
public static String suggestSetterName(IJavaProject project,
String fieldName, int modifiers, boolean isBoolean,
String[] excludedNames) {
return String.valueOf(suggestSetterName(project, fieldName
.toCharArray(), modifiers, isBoolean,
convertStringToChars(excludedNames)));
}
private static char[] suggestAccessorName(IJavaProject project,
char[] fieldName, int modifiers) {
char[] name = removePrefixAndSuffixForFieldName(project, fieldName,
modifiers);
if (name.length > 0 && Character.isLowerCase(name[0])) {
name[0] = Character.toUpperCase(name[0]);
}
return name;
}
private static char[] suggestNewName(char[] name, char[][] excludedNames) {
if (excludedNames == null) {
return name;
}
char[] newName = name;
int count = 2;
int i = 0;
while (i < excludedNames.length) {
if (CharOperation.equals(newName, excludedNames[i], false)) {
newName = CharOperation.concat(name, String.valueOf(count++)
.toCharArray());
i = 0;
} else {
i++;
}
}
return newName;
}
private static String[] convertCharsToString(char[][] c) {
int length = c == null ? 0 : c.length;
String[] s = new String[length];
for (int i = 0; i < length; i++) {
s[i] = String.valueOf(c[i]);
}
return s;
}
private static char[][] convertStringToChars(String[] s) {
int length = s == null ? 0 : s.length;
char[][] c = new char[length][];
for (int i = 0; i < length; i++) {
if (s[i] == null) {
c[i] = CharOperation.NO_CHAR;
} else {
c[i] = s[i].toCharArray();
}
}
return c;
}
}
The table below shows all metrics for NamingConventions.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 70.00 | Number of blocks | |
| BLOCK_COMMENT | 0.00 | Number of block comment lines | |
| COMMENTS | 610.00 | Comment lines | |
| COMMENT_DENSITY | 1.79 | Comment density | |
| COMPARISONS | 37.00 | Number of comparison operators | |
| CYCLOMATIC | 76.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 22.00 | Comments in declarations | |
| DOC_COMMENT | 603.00 | Number of javadoc comment lines | |
| ELOC | 340.00 | Effective lines of code | |
| EXEC_COMMENTS | 3.00 | Comments in executable code | |
| EXITS | 33.00 | Procedure exits | |
| FUNCTIONS | 27.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 91.50 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 116.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 | 0.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 | 1.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 | 0.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 | 0.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 | 1.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 1.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 1.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 0.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 | 0.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 | 2.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 | 0.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 1953.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 | 0.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 | 0.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 | 0.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 | 0.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 | 2.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 | 1071.00 | Number of lines in the source file | |
| LINE_COMMENT | 7.00 | Number of line comments | |
| LOC | 401.00 | Lines of code | |
| LOGICAL_LINES | 153.00 | Number of statements | |
| LOOPS | 5.00 | Number of loops | |
| NEST_DEPTH | 6.00 | Maximum nesting depth | |
| OPERANDS | 919.00 | Number of operands | |
| OPERATORS | 2034.00 | Number of operators | |
| PARAMS | 84.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 2953.00 | Halstead program length | |
| PROGRAM_VOCAB | 277.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 32.00 | Number of return points from functions | |
| SIZE | 40322.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 231.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 46.00 | Number of unique operators | |
| WHITESPACE | 60.00 | Number of whitespace lines | |