Types.java
| Index Score | ||
|---|---|---|
 |
 |
org.gjt.sp.jedit.bsh |
 |
 |
jEdit |
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 | |
|---|---|---|
| JAVA0034 | JAVA0034 Missing braces in if statement |  |
| EXEC_COMMENTS | Comments in executable code | |
| COMPARISONS | Number of comparison operators | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| LINE_COMMENT | Number of line comments | |
| CYCLOMATIC | Cyclomatic complexity | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| RETURNS | Number of return points from functions | |
| COMMENTS | Comment lines | |
| DOC_COMMENT | Number of javadoc comment lines | |
| JAVA0035 | JAVA0035 Missing braces in for statement | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| SIZE | Size of the file in bytes | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| LINES | Number of lines in the source file | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| UNIQUE_OPERATORS | Number of unique operators | |
| PARAMS | Number of formal parameter declarations | |
| BLOCKS | Number of blocks | |
| FUNCTIONS | Number of function declarations | |
/*****************************************************************************
* *
* This file is part of the BeanShell Java Scripting distribution. *
* Documentation and updates may be found at http://www.beanshell.org/ *
* *
* Sun Public License Notice: *
* *
* The contents of this file are subject to the Sun Public License Version *
* 1.0 (the "License"); you may not use this file except in compliance with *
* the License. A copy of the License is available at http://www.sun.com *
* *
* The Original Code is BeanShell. The Initial Developer of the Original *
* Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright *
* (C) 2000. All Rights Reserved. *
* *
* GNU Public License Notice: *
* *
* Alternatively, the contents of this file may be used under the terms of *
* the GNU Lesser General Public License (the "LGPL"), in which case the *
* provisions of LGPL are applicable instead of those above. If you wish to *
* allow use of your version of this file only under the terms of the LGPL *
* and not to allow others to use your version of this file under the SPL, *
* indicate your decision by deleting the provisions above and replace *
* them with the notice and other provisions required by the LGPL. If you *
* do not delete the provisions above, a recipient may use your version of *
* this file under either the SPL or the LGPL. *
* *
* Patrick Niemeyer (pat@pat.net) *
* Author of Learning Java, O'Reilly & Associates *
* http://www.pat.net/~pat/ *
* *
*****************************************************************************/
package org.gjt.sp.jedit.bsh;
/**
Static routines supporing type comparison and conversion in BeanShell.
The following are notes on type comparison and conversion in BeanShell.
*/
class Types
{
/*
Type conversion identifiers. An ASSIGNMENT allows conversions that would
normally happen on assignment. A CAST performs numeric conversions to smaller
types (as in an explicit Java cast) and things allowed only in variable and array
declarations (e.g. byte b = 42;)
*/
static final int CAST=0, ASSIGNMENT=1;
static final int
JAVA_BASE_ASSIGNABLE = 1,
JAVA_BOX_TYPES_ASSIGABLE = 2,
JAVA_VARARGS_ASSIGNABLE = 3,
BSH_ASSIGNABLE = 4;
static final int
FIRST_ROUND_ASSIGNABLE = JAVA_BASE_ASSIGNABLE,
LAST_ROUND_ASSIGNABLE = BSH_ASSIGNABLE;
/**
Special value that indicates by identity that the result of a cast
operation was a valid cast. This is used by castObject() and
castPrimitive() in the checkOnly mode of operation. This value is a
Primitive type so that it can be returned by castPrimitive.
*/
static Primitive VALID_CAST = new Primitive(1);
static Primitive INVALID_CAST = new Primitive(-1);
/**
Get the Java types of the arguments.
*/
public static Class[] getTypes( Object[] args )
{
if ( args == null )
return new Class[0];
Class[] types = new Class[ args.length ];
for( int i=0; i<args.length; i++ )
{
if ( args[i] == null )
types[i] = null;
else
if ( args[i] instanceof Primitive )
types[i] = ((Primitive)args[i]).getType();
else
types[i] = args[i].getClass();
}
return types;
}
/**
Is the 'from' signature (argument types) assignable to the 'to'
signature (candidate method types)
This method handles the special case of null values in 'to' types
indicating a loose type and matching anything.
*/
/* Should check for strict java here and limit to isJavaAssignable() */
static boolean isSignatureAssignable( Class[] from, Class[] to, int round )
{
if ( round != JAVA_VARARGS_ASSIGNABLE && from.length != to.length )
return false;
switch ( round )
{
case JAVA_BASE_ASSIGNABLE:
for( int i=0; i<from.length; i++ )
if ( !isJavaBaseAssignable( to[i], from[i] ) )
return false;
return true;
case JAVA_BOX_TYPES_ASSIGABLE:
for( int i=0; i<from.length; i++ )
if ( !isJavaBoxTypesAssignable( to[i], from[i] ) )
return false;
return true;
case JAVA_VARARGS_ASSIGNABLE:
return isSignatureVarargsAssignable( from, to );
case BSH_ASSIGNABLE:
for( int i=0; i<from.length; i++ )
if ( !isBshAssignable( to[i], from[i] ) )
return false;
return true;
default:
throw new InterpreterError("bad case");
}
}
private static boolean isSignatureVarargsAssignable(
Class[] from, Class[] to )
{
return false;
}
/**
Test if a conversion of the rhsType type to the lhsType type is legal via
standard Java assignment conversion rules (i.e. without a cast).
The rules include Java 5 autoboxing/unboxing.
<p/>
For Java primitive TYPE classes this method takes primitive promotion
into account. The ordinary Class.isAssignableFrom() does not take
primitive promotion conversions into account. Note that Java allows
additional assignments without a cast in combination with variable
declarations and array allocations. Those are handled elsewhere
(maybe should be here with a flag?)
<p/>
This class accepts a null rhsType type indicating that the rhsType was the
value Primitive.NULL and allows it to be assigned to any reference lhsType
type (non primitive).
<p/>
Note that the getAssignableForm() method is the primary bsh method for
checking assignability. It adds additional bsh conversions, etc.
@see #isBshAssignable( Class, Class )
@param lhsType assigning from rhsType to lhsType
@param rhsType assigning from rhsType to lhsType
*/
static boolean isJavaAssignable( Class lhsType, Class rhsType ) {
return isJavaBaseAssignable( lhsType, rhsType )
|| isJavaBoxTypesAssignable( lhsType, rhsType );
}
/**
Is the assignment legal via original Java (up to version 1.4)
assignment rules, not including auto-boxing/unboxing.
@param rhsType may be null to indicate primitive null value
*/
static boolean isJavaBaseAssignable( Class lhsType, Class rhsType )
{
/*
Assignment to loose type, defer to bsh extensions
Note: we could shortcut this here:
if ( lhsType == null ) return true;
rather than forcing another round. It's not strictly a Java issue,
so does it belong here?
*/
if ( lhsType == null )
return false;
// null rhs type corresponds to type of Primitive.NULL
// assignable to any object type
if ( rhsType == null )
return !lhsType.isPrimitive();
if ( lhsType.isPrimitive() && rhsType.isPrimitive() )
{
if ( lhsType == rhsType )
return true;
// handle primitive widening conversions - JLS 5.1.2
if ( (rhsType == Byte.TYPE) &&
(lhsType == Short.TYPE || lhsType == Integer.TYPE
|| lhsType == Long.TYPE || lhsType == Float.TYPE
|| lhsType == Double.TYPE))
return true;
if ( (rhsType == Short.TYPE) &&
(lhsType == Integer.TYPE || lhsType == Long.TYPE ||
lhsType == Float.TYPE || lhsType == Double.TYPE))
return true;
if ((rhsType == Character.TYPE) &&
(lhsType == Integer.TYPE || lhsType == Long.TYPE ||
lhsType == Float.TYPE || lhsType == Double.TYPE))
return true;
if ((rhsType == Integer.TYPE) &&
(lhsType == Long.TYPE || lhsType == Float.TYPE ||
lhsType == Double.TYPE))
return true;
if ((rhsType == Long.TYPE) &&
(lhsType == Float.TYPE || lhsType == Double.TYPE))
return true;
if ((rhsType == Float.TYPE) && (lhsType == Double.TYPE))
return true;
}
else
if ( lhsType.isAssignableFrom(rhsType) )
return true;
return false;
}
/**
Determine if the type is assignable via Java boxing/unboxing rules.
*/
static boolean isJavaBoxTypesAssignable(
Class lhsType, Class rhsType )
{
// Assignment to loose type... defer to bsh extensions
if ( lhsType == null )
return false;
// prim can be boxed and assigned to Object
if ( lhsType == Object.class )
return true;
// prim numeric type can be boxed and assigned to number
if ( lhsType == Number.class
&& rhsType != Character.TYPE
&& rhsType != Boolean.TYPE
)
return true;
// General case prim type to wrapper or vice versa.
// I don't know if this is faster than a flat list of 'if's like above.
// wrapperMap maps both prim to wrapper and wrapper to prim types,
// so this test is symmetric
if ( Primitive.wrapperMap.get( lhsType ) == rhsType )
return true;
return false;
}
/**
Test if a type can be converted to another type via BeanShell
extended syntax rules (a superset of Java conversion rules).
*/
static boolean isBshAssignable( Class toType, Class fromType )
{
try {
return castObject(
toType, fromType, null/*fromValue*/,
ASSIGNMENT, true/*checkOnly*/
) == VALID_CAST;
} catch ( UtilEvalError e ) {
// This should not happen with checkOnly true
throw new InterpreterError("err in cast check: "+e);
}
}
/**
Attempt to cast an object instance to a new type if possible via
BeanShell extended syntax rules. These rules are always a superset of
Java conversion rules. If you wish to impose context sensitive
conversion rules then you must test before calling this method.
<p/>
This method can handle fromValue Primitive types (representing
primitive casts) as well as fromValue object casts requiring interface
generation, etc.
@param toType the class type of the cast result, which may include
primitive types, e.g. Byte.TYPE
@param fromValue an Object or bsh.Primitive primitive value (including
Primitive.NULL or Primitive.VOID )
@see #isBshAssignable( Class, Class )
*/
public static Object castObject(
Object fromValue, Class toType, int operation )
throws UtilEvalError
{
if ( fromValue == null )
throw new InterpreterError("null fromValue");
Class fromType =
fromValue instanceof Primitive ?
((Primitive)fromValue).getType()
: fromValue.getClass();
return castObject(
toType, fromType, fromValue, operation, false/*checkonly*/ );
}
/**
Perform a type conversion or test if a type conversion is possible with
respect to BeanShell extended rules. These rules are always a superset of
the Java language rules, so this method can also perform (but not test)
any Java language assignment or cast conversion.
<p/>
This method can perform the functionality of testing if an assignment
or cast is ultimately possible (with respect to BeanShell) as well as the
functionality of performing the necessary conversion of a value based
on the specified target type. This combined functionality is done for
expediency and could be separated later.
<p/>
Other methods such as isJavaAssignable() should be used to determine the
suitability of an assignment in a fine grained or restrictive way based
on context before calling this method
<p/>
A CAST is stronger than an ASSIGNMENT operation in that it will attempt to
perform primtive operations that cast to a smaller type. e.g. (byte)myLong;
These are used in explicit primitive casts, primitive delclarations and
array declarations. I don't believe there are any object conversions which are
different between ASSIGNMENT and CAST (e.g. scripted object to interface proxy
in bsh is done on assignment as well as cast).
<p/>
This method does not obey strictJava(), you must test first before
using this method if you care. (See #isJavaAssignable()).
<p/>
@param toType the class type of the cast result, which may include
primitive types, e.g. Byte.TYPE. toType may be null to indicate a
loose type assignment (which matches any fromType).
@param fromType is the class type of the value to be cast including
java primitive TYPE classes for primitives.
If fromValue is (or would be) Primitive.NULL then fromType should be null.
@param fromValue an Object or bsh.Primitive primitive value (including
Primitive.NULL or Primitive.VOID )
@param checkOnly If checkOnly is true then fromValue must be null.
FromType is checked for the cast to toType...
If checkOnly is false then fromValue must be non-null
(Primitive.NULL is ok) and the actual cast is performed.
@throws UtilEvalError on invalid assignment (when operation is
assignment ).
@throws UtilTargetError wrapping ClassCastException on cast error
(when operation is cast)
@param operation is Types.CAST or Types.ASSIGNMENT
@see org.gjt.sp.jedit.bsh.Primitive.getType()
*/
/*
Notes: This method is currently responsible for auto-boxing/unboxing
conversions... Where does that need to go?
*/
private static Object castObject(
Class toType, Class fromType, Object fromValue,
int operation, boolean checkOnly )
throws UtilEvalError
{
/*
Lots of preconditions checked here...
Once things are running smoothly we might comment these out
(That's what assertions are for).
*/
if ( checkOnly && fromValue != null )
throw new InterpreterError("bad cast params 1");
if ( !checkOnly && fromValue == null )
throw new InterpreterError("bad cast params 2");
if ( fromType == Primitive.class )
throw new InterpreterError("bad from Type, need to unwrap");
if ( fromValue == Primitive.NULL && fromType != null )
throw new InterpreterError("inconsistent args 1");
if ( fromValue == Primitive.VOID && fromType != Void.TYPE )
throw new InterpreterError("inconsistent args 2");
if ( toType == Void.TYPE )
throw new InterpreterError("loose toType should be null");
// assignment to loose type, void type, or exactly same type
if ( toType == null || toType == fromType )
return checkOnly ? VALID_CAST :
fromValue;
// Casting to primitive type
if ( toType.isPrimitive() )
{
if ( fromType == Void.TYPE || fromType == null
|| fromType.isPrimitive() )
{
// Both primitives, do primitive cast
return Primitive.castPrimitive(
toType, fromType, (Primitive)fromValue,
checkOnly, operation );
} else
{
if ( Primitive.isWrapperType( fromType ) )
{
// wrapper to primitive
// Convert value to Primitive and check/cast it.
//Object r = checkOnly ? VALID_CAST :
Class unboxedFromType = Primitive.unboxType( fromType );
Primitive primFromValue;
if ( checkOnly )
primFromValue = null; // must be null in checkOnly
else
primFromValue = (Primitive)Primitive.wrap(
fromValue, unboxedFromType );
return Primitive.castPrimitive(
toType, unboxedFromType, primFromValue,
checkOnly, operation );
} else
{
// Cannot cast from arbitrary object to primitive
if ( checkOnly )
return INVALID_CAST;
else
throw castError( toType, fromType, operation );
}
}
}
// Else, casting to reference type
// Casting from primitive or void (to reference type)
if ( fromType == Void.TYPE || fromType == null
|| fromType.isPrimitive() )
{
// cast from primitive to wrapper type
if ( Primitive.isWrapperType( toType )
&& fromType != Void.TYPE && fromType != null )
{
// primitive to wrapper type
return checkOnly ? VALID_CAST :
Primitive.castWrapper(
Primitive.unboxType(toType),
((Primitive)fromValue).getValue() );
}
// Primitive (not null or void) to Object.class type
if ( toType == Object.class
&& fromType != Void.TYPE && fromType != null )
{
// box it
return checkOnly ? VALID_CAST :
((Primitive)fromValue).getValue();
}
// Primitive to arbitrary object type.
// Allow Primitive.castToType() to handle it as well as cases of
// Primitive.NULL and Primitive.VOID
return Primitive.castPrimitive(
toType, fromType, (Primitive)fromValue, checkOnly, operation );
}
// If type already assignable no cast necessary
// We do this last to allow various errors above to be caught.
// e.g cast Primitive.Void to Object would pass this
if ( toType.isAssignableFrom( fromType ) )
return checkOnly ? VALID_CAST :
fromValue;
// Can we use the proxy mechanism to cast a bsh.This to
// the correct interface?
if ( toType.isInterface()
&& org.gjt.sp.jedit.bsh.This.class.isAssignableFrom( fromType )
&& Capabilities.canGenerateInterfaces()
)
return checkOnly ? VALID_CAST :
((org.gjt.sp.jedit.bsh.This)fromValue).getInterface( toType );
// Both numeric wrapper types?
// Try numeric style promotion wrapper cast
if ( Primitive.isWrapperType( toType )
&& Primitive.isWrapperType( fromType )
)
return checkOnly ? VALID_CAST :
Primitive.castWrapper( toType, fromValue );
if ( checkOnly )
return INVALID_CAST;
else
throw castError( toType, fromType , operation );
}
/**
Return a UtilEvalError or UtilTargetError wrapping a ClassCastException
describing an illegal assignment or illegal cast, respectively.
*/
static UtilEvalError castError(
Class lhsType, Class rhsType, int operation )
{
return castError(
Reflect.normalizeClassName(lhsType),
Reflect.normalizeClassName(rhsType), operation );
}
static UtilEvalError castError(
String lhs, String rhs, int operation )
{
if ( operation == ASSIGNMENT )
return new UtilEvalError (
"Can't assign " + rhs + " to "+ lhs );
Exception cce = new ClassCastException(
"Cannot cast " + rhs + " to " + lhs );
return new UtilTargetError( cce );
}
}
The table below shows all metrics for Types.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 23.00 | Number of blocks | |
| BLOCK_COMMENT | 23.00 | Number of block comment lines | |
| COMMENTS | 228.00 | Comment lines | |
| COMMENT_DENSITY | 1.11 | Comment density | |
| COMPARISONS | 89.00 | Number of comparison operators | |
| CYCLOMATIC | 110.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 15.00 | Comments in declarations | |
| DOC_COMMENT | 171.00 | Number of javadoc comment lines | |
| ELOC | 206.00 | Effective lines of code | |
| EXEC_COMMENTS | 25.00 | Comments in executable code | |
| EXITS | 23.00 | Procedure exits | |
| FUNCTIONS | 11.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 86.95 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 88.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 | 1.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 | 40.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 3.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 | 0.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 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 0.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 | 13.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 9.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 1.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 | 1.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 0.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 | 0.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 | 0.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 939.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 | 2.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 | 1.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 | 0.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 | 530.00 | Number of lines in the source file | |
| LINE_COMMENT | 34.00 | Number of line comments | |
| LOC | 253.00 | Lines of code | |
| LOGICAL_LINES | 79.00 | Number of statements | |
| LOOPS | 4.00 | Number of loops | |
| NEST_DEPTH | 4.00 | Maximum nesting depth | |
| OPERANDS | 514.00 | Number of operands | |
| OPERATORS | 1003.00 | Number of operators | |
| PARAMS | 28.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 1517.00 | Halstead program length | |
| PROGRAM_VOCAB | 178.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 60.00 | Number of return points from functions | |
| SIZE | 18496.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 133.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 45.00 | Number of unique operators | |
| WHITESPACE | 49.00 | Number of whitespace lines | |