CursorableLinkedList.java
| Index Score | ||
|---|---|---|
 |
 |
org.apache.commons.collections |
 |
|
Commons Collections |
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 | |
|---|---|---|
| RETURNS | Number of return points from functions |  |
| CYCLOMATIC | Cyclomatic complexity | |
| LOOPS | Number of loops | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| BLOCKS | Number of blocks | |
| FUNCTIONS | Number of function declarations | |
| DOC_COMMENT | Number of javadoc comment lines | |
| DECL_COMMENTS | Comments in declarations | |
| COMPARISONS | Number of comparison operators | |
| SIZE | Size of the file in bytes | |
| COMMENTS | Comment lines | |
| LINES | Number of lines in the source file | |
| OPERATORS | Number of operators | |
| LOGICAL_LINES | Number of statements | |
| PROGRAM_LENGTH | Halstead program length | |
| LOC | Lines of code | |
| JAVA0020 | JAVA0020 Field name does not have required form | |
| ELOC | Effective lines of code | |
| PARAMS | Number of formal parameter declarations | |
| OPERANDS | Number of operands | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| UNIQUE_OPERANDS | Number of unique operands | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| JAVA0254 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0279 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| EXITS | Procedure exits | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| UNIQUE_OPERATORS | Number of unique operators | |
| WHITESPACE | Number of whitespace lines | |
| JAVA0282 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| LINE_COMMENT | Number of line comments | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0132 | JAVA0132 Method overload with compatible signature | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.collections;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.lang.ref.WeakReference;
/**
* A doubly-linked list implementation of the {@link List} interface,
* supporting a {@link ListIterator} that allows concurrent modifications
* to the underlying list.
* <p>
* Implements all of the optional {@link List} operations, the
* stack/queue/dequeue operations available in {@link java.util.LinkedList}
* and supports a {@link ListIterator} that allows concurrent modifications
* to the underlying list (see {@link #cursor}).
* <p>
* <b>Note that this implementation is not synchronized.</b>
*
* @deprecated Use new version in list subpackage, which has been rewritten
* and now returns the cursor from the listIterator method. Will be removed in v4.0
* @see java.util.LinkedList
* @since Commons Collections 1.0
* @version $Revision: 637494 $ $Date: 2008-03-15 19:31:23 -0400 (Sat, 15 Mar 2008) $
*
* @author Rodney Waldhoff
* @author Janek Bogucki
* @author Simon Kitching
*/
public class CursorableLinkedList implements List, Serializable {
/** Ensure serialization compatibility */
private static final long serialVersionUID = 8836393098519411393L;
//--- public methods ---------------------------------------------
/**
* Appends the specified element to the end of this list.
*
* @param o element to be appended to this list.
* @return <tt>true</tt>
*/
public boolean add(Object o) {
insertListable(_head.prev(),null,o);
return true;
}
/**
* Inserts the specified element at the specified position in this list.
* Shifts the element currently at that position (if any) and any subsequent
* elements to the right (adds one to their indices).
*
* @param index index at which the specified element is to be inserted.
* @param element element to be inserted.
*
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of the specified
* element prevents it from being added to this list.
* @throws IndexOutOfBoundsException if the index is out of range
* (index < 0 || index > size()).
*/
public void add(int index, Object element) {
if(index == _size) {
add(element);
} else {
if(index < 0 || index > _size) {
throw new IndexOutOfBoundsException(String.valueOf(index) + " < 0 or " + String.valueOf(index) + " > " + _size);
}
Listable succ = (isEmpty() ? null : getListableAt(index));
Listable pred = (null == succ ? null : succ.prev());
insertListable(pred,succ,element);
}
}
/**
* Appends all of the elements in the specified collection to the end of
* this list, in the order that they are returned by the specified
* {@link Collection}'s {@link Iterator}. The behavior of this operation is
* unspecified if the specified collection is modified while
* the operation is in progress. (Note that this will occur if the
* specified collection is this list, and it's nonempty.)
*
* @param c collection whose elements are to be added to this list.
* @return <tt>true</tt> if this list changed as a result of the call.
*
* @throws ClassCastException if the class of an element in the specified
* collection prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of an element in the
* specified collection prevents it from being added to this
* list.
*/
public boolean addAll(Collection c) {
if(c.isEmpty()) {
return false;
}
Iterator it = c.iterator();
while(it.hasNext()) {
insertListable(_head.prev(),null,it.next());
}
return true;
}
/**
* Inserts all of the elements in the specified collection into this
* list at the specified position. Shifts the element currently at
* that position (if any) and any subsequent elements to the right
* (increases their indices). The new elements will appear in this
* list in the order that they are returned by the specified
* {@link Collection}'s {@link Iterator}. The behavior of this operation is
* unspecified if the specified collection is modified while the
* operation is in progress. (Note that this will occur if the specified
* collection is this list, and it's nonempty.)
*
* @param index index at which to insert first element from the specified
* collection.
* @param c elements to be inserted into this list.
* @return <tt>true</tt> if this list changed as a result of the call.
*
* @throws ClassCastException if the class of one of elements of the
* specified collection prevents it from being added to this
* list.
* @throws IllegalArgumentException if some aspect of one of elements of
* the specified collection prevents it from being added to
* this list.
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index > size()).
*/
public boolean addAll(int index, Collection c) {
if(c.isEmpty()) {
return false;
} else if(_size == index || _size == 0) {
return addAll(c);
} else {
Listable succ = getListableAt(index);
Listable pred = (null == succ) ? null : succ.prev();
Iterator it = c.iterator();
while(it.hasNext()) {
pred = insertListable(pred,succ,it.next());
}
return true;
}
}
/**
* Inserts the specified element at the beginning of this list.
* (Equivalent to {@link #add(int,java.lang.Object) <tt>add(0,o)</tt>}).
*
* @param o element to be prepended to this list.
* @return <tt>true</tt>
*/
public boolean addFirst(Object o) {
insertListable(null,_head.next(),o);
return true;
}
/**
* Inserts the specified element at the end of this list.
* (Equivalent to {@link #add(java.lang.Object)}).
*
* @param o element to be appended to this list.
* @return <tt>true</tt>
*/
public boolean addLast(Object o) {
insertListable(_head.prev(),null,o);
return true;
}
/**
* Removes all of the elements from this list. This
* list will be empty after this call returns (unless
* it throws an exception).
*/
public void clear() {
/*
// this is the quick way, but would force us
// to break all the cursors
_modCount++;
_head.setNext(null);
_head.setPrev(null);
_size = 0;
*/
Iterator it = iterator();
while(it.hasNext()) {
it.next();
it.remove();
}
}
/**
* Returns <tt>true</tt> if this list contains the specified element.
* More formally, returns <tt>true</tt> if and only if this list contains
* at least one element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this list is to be tested.
* @return <tt>true</tt> if this list contains the specified element.
*/
public boolean contains(Object o) {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if((null == o && null == elt.value()) ||
(o != null && o.equals(elt.value()))) {
return true;
}
}
return false;
}
/**
* Returns <tt>true</tt> if this list contains all of the elements of the
* specified collection.
*
* @param c collection to be checked for containment in this list.
* @return <tt>true</tt> if this list contains all of the elements of the
* specified collection.
*/
public boolean containsAll(Collection c) {
Iterator it = c.iterator();
while(it.hasNext()) {
if(!this.contains(it.next())) {
return false;
}
}
return true;
}
/**
* Returns a {@link ListIterator} for iterating through the
* elements of this list. Unlike {@link #iterator}, a cursor
* is not bothered by concurrent modifications to the
* underlying list.
* <p>
* Specifically, when elements are added to the list before or
* after the cursor, the cursor simply picks them up automatically.
* When the "current" (i.e., last returned by {@link ListIterator#next}
* or {@link ListIterator#previous}) element of the list is removed,
* the cursor automatically adjusts to the change (invalidating the
* last returned value--i.e., it cannot be removed).
* <p>
* Note that the returned {@link ListIterator} does not support the
* {@link ListIterator#nextIndex} and {@link ListIterator#previousIndex}
* methods (they throw {@link UnsupportedOperationException} when invoked.
* <p>
* Historical Note: In previous versions of this class, the object
* returned from this method was required to be explicitly closed. This
* is no longer necessary.
*
* @see #cursor(int)
* @see #listIterator
* @see CursorableLinkedList.Cursor
*/
public CursorableLinkedList.Cursor cursor() {
return new Cursor(0);
}
/**
* Returns a {@link ListIterator} for iterating through the
* elements of this list, initialized such that
* {@link ListIterator#next} will return the element at
* the specified index (if any) and {@link ListIterator#previous}
* will return the element immediately preceding it (if any).
* Unlike {@link #iterator}, a cursor
* is not bothered by concurrent modifications to the
* underlying list.
*
* @see #cursor
* @see #listIterator(int)
* @see CursorableLinkedList.Cursor
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index > size()).
*/
public CursorableLinkedList.Cursor cursor(int i) {
return new Cursor(i);
}
/**
* Compares the specified object with this list for equality. Returns
* <tt>true</tt> if and only if the specified object is also a list, both
* lists have the same size, and all corresponding pairs of elements in
* the two lists are <i>equal</i>. (Two elements <tt>e1</tt> and
* <tt>e2</tt> are <i>equal</i> if <tt>(e1==null ? e2==null :
* e1.equals(e2))</tt>.) In other words, two lists are defined to be
* equal if they contain the same elements in the same order. This
* definition ensures that the equals method works properly across
* different implementations of the <tt>List</tt> interface.
*
* @param o the object to be compared for equality with this list.
* @return <tt>true</tt> if the specified object is equal to this list.
*/
public boolean equals(Object o) {
if(o == this) {
return true;
} else if(!(o instanceof List)) {
return false;
}
Iterator it = ((List)o).listIterator();
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if(!it.hasNext() || (null == elt.value() ? null != it.next() : !(elt.value().equals(it.next()))) ) {
return false;
}
}
return !it.hasNext();
}
/**
* Returns the element at the specified position in this list.
*
* @param index index of element to return.
* @return the element at the specified position in this list.
*
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index >= size()).
*/
public Object get(int index) {
return getListableAt(index).value();
}
/**
* Returns the element at the beginning of this list.
*/
public Object getFirst() {
try {
return _head.next().value();
} catch(NullPointerException e) {
throw new NoSuchElementException();
}
}
/**
* Returns the element at the end of this list.
*/
public Object getLast() {
try {
return _head.prev().value();
} catch(NullPointerException e) {
throw new NoSuchElementException();
}
}
/**
* Returns the hash code value for this list. The hash code of a list
* is defined to be the result of the following calculation:
* <pre>
* hashCode = 1;
* Iterator i = list.iterator();
* while (i.hasNext()) {
* Object obj = i.next();
* hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
* }
* </pre>
* This ensures that <tt>list1.equals(list2)</tt> implies that
* <tt>list1.hashCode()==list2.hashCode()</tt> for any two lists,
* <tt>list1</tt> and <tt>list2</tt>, as required by the general
* contract of <tt>Object.hashCode</tt>.
*
* @return the hash code value for this list.
* @see Object#hashCode()
* @see Object#equals(Object)
* @see #equals(Object)
*/
public int hashCode() {
int hash = 1;
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
hash = 31*hash + (null == elt.value() ? 0 : elt.value().hashCode());
}
return hash;
}
/**
* Returns the index in this list of the first occurrence of the specified
* element, or -1 if this list does not contain this element.
* More formally, returns the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*
* @param o element to search for.
* @return the index in this list of the first occurrence of the specified
* element, or -1 if this list does not contain this element.
*/
public int indexOf(Object o) {
int ndx = 0;
// perform the null check outside of the loop to save checking every
// single time through the loop.
if (null == o) {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if (null == elt.value()) {
return ndx;
}
ndx++;
}
} else {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if (o.equals(elt.value())) {
return ndx;
}
ndx++;
}
}
return -1;
}
/**
* Returns <tt>true</tt> if this list contains no elements.
* @return <tt>true</tt> if this list contains no elements.
*/
public boolean isEmpty() {
return(0 == _size);
}
/**
* Returns a fail-fast iterator.
* @see List#iterator
*/
public Iterator iterator() {
return listIterator(0);
}
/**
* Returns the index in this list of the last occurrence of the specified
* element, or -1 if this list does not contain this element.
* More formally, returns the highest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*
* @param o element to search for.
* @return the index in this list of the last occurrence of the specified
* element, or -1 if this list does not contain this element.
*/
public int lastIndexOf(Object o) {
int ndx = _size-1;
// perform the null check outside of the loop to save checking every
// single time through the loop.
if (null == o) {
for(Listable elt = _head.prev(), past = null; null != elt && past != _head.next(); elt = (past = elt).prev()) {
if (null == elt.value()) {
return ndx;
}
ndx--;
}
} else {
for(Listable elt = _head.prev(), past = null; null != elt && past != _head.next(); elt = (past = elt).prev()) {
if (o.equals(elt.value())) {
return ndx;
}
ndx--;
}
}
return -1;
}
/**
* Returns a fail-fast ListIterator.
* @see List#listIterator
*/
public ListIterator listIterator() {
return listIterator(0);
}
/**
* Returns a fail-fast ListIterator.
* @see List#listIterator(int)
*/
public ListIterator listIterator(int index) {
if(index<0 || index > _size) {
throw new IndexOutOfBoundsException(index + " < 0 or > " + _size);
}
return new ListIter(index);
}
/**
* Removes the first occurrence in this list of the specified element.
* If this list does not contain the element, it is
* unchanged. More formally, removes the element with the lowest index i
* such that <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt> (if
* such an element exists).
*
* @param o element to be removed from this list, if present.
* @return <tt>true</tt> if this list contained the specified element.
*/
public boolean remove(Object o) {
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if(null == o && null == elt.value()) {
removeListable(elt);
return true;
} else if(o != null && o.equals(elt.value())) {
removeListable(elt);
return true;
}
}
return false;
}
/**
* Removes the element at the specified position in this list (optional
* operation). Shifts any subsequent elements to the left (subtracts one
* from their indices). Returns the element that was removed from the
* list.
*
* @param index the index of the element to removed.
* @return the element previously at the specified position.
*
* @throws IndexOutOfBoundsException if the index is out of range (index
* < 0 || index >= size()).
*/
public Object remove(int index) {
Listable elt = getListableAt(index);
Object ret = elt.value();
removeListable(elt);
return ret;
}
/**
* Removes from this list all the elements that are contained in the
* specified collection.
*
* @param c collection that defines which elements will be removed from
* this list.
* @return <tt>true</tt> if this list changed as a result of the call.
*/
public boolean removeAll(Collection c) {
if(0 == c.size() || 0 == _size) {
return false;
} else {
boolean changed = false;
Iterator it = iterator();
while(it.hasNext()) {
if(c.contains(it.next())) {
it.remove();
changed = true;
}
}
return changed;
}
}
/**
* Removes the first element of this list, if any.
*/
public Object removeFirst() {
if(_head.next() != null) {
Object val = _head.next().value();
removeListable(_head.next());
return val;
} else {
throw new NoSuchElementException();
}
}
/**
* Removes the last element of this list, if any.
*/
public Object removeLast() {
if(_head.prev() != null) {
Object val = _head.prev().value();
removeListable(_head.prev());
return val;
} else {
throw new NoSuchElementException();
}
}
/**
* Retains only the elements in this list that are contained in the
* specified collection. In other words, removes
* from this list all the elements that are not contained in the specified
* collection.
*
* @param c collection that defines which elements this set will retain.
*
* @return <tt>true</tt> if this list changed as a result of the call.
*/
public boolean retainAll(Collection c) {
boolean changed = false;
Iterator it = iterator();
while(it.hasNext()) {
if(!c.contains(it.next())) {
it.remove();
changed = true;
}
}
return changed;
}
/**
* Replaces the element at the specified position in this list with the
* specified element.
*
* @param index index of element to replace.
* @param element element to be stored at the specified position.
* @return the element previously at the specified position.
*
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this list.
* @throws IllegalArgumentException if some aspect of the specified
* element prevents it from being added to this list.
* @throws IndexOutOfBoundsException if the index is out of range
* (index < 0 || index >= size()).
*/
public Object set(int index, Object element) {
Listable elt = getListableAt(index);
Object val = elt.setValue(element);
broadcastListableChanged(elt);
return val;
}
/**
* Returns the number of elements in this list.
* @return the number of elements in this list.
*/
public int size() {
return _size;
}
/**
* Returns an array containing all of the elements in this list in proper
* sequence. Obeys the general contract of the {@link Collection#toArray} method.
*
* @return an array containing all of the elements in this list in proper
* sequence.
*/
public Object[] toArray() {
Object[] array = new Object[_size];
int i = 0;
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
array[i++] = elt.value();
}
return array;
}
/**
* Returns an array containing all of the elements in this list in proper
* sequence; the runtime type of the returned array is that of the
* specified array. Obeys the general contract of the
* {@link Collection#toArray} method.
*
* @param a the array into which the elements of this list are to
* be stored, if it is big enough; otherwise, a new array of the
* same runtime type is allocated for this purpose.
* @return an array containing the elements of this list.
* @exception ArrayStoreException
* if the runtime type of the specified array
* is not a supertype of the runtime type of every element in
* this list.
*/
public Object[] toArray(Object a[]) {
if(a.length < _size) {
a = (Object[])Array.newInstance(a.getClass().getComponentType(), _size);
}
int i = 0;
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
a[i++] = elt.value();
}
if(a.length > _size) {
a[_size] = null; // should we null out the rest of the array also? java.util.LinkedList doesn't
}
return a;
}
/**
* Returns a {@link String} representation of this list, suitable for debugging.
* @return a {@link String} representation of this list, suitable for debugging.
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("[");
for(Listable elt = _head.next(), past = null; null != elt && past != _head.prev(); elt = (past = elt).next()) {
if(_head.next() != elt) {
buf.append(", ");
}
buf.append(elt.value());
}
buf.append("]");
return buf.toString();
}
/**
* Returns a fail-fast sublist.
* @see List#subList(int,int)
*/
public List subList(int i, int j) {
if(i < 0 || j > _size || i > j) {
throw new IndexOutOfBoundsException();
} else if(i == 0 && j == _size) {
return this;
} else {
return new CursorableSubList(this,i,j);
}
}
//--- protected methods ------------------------------------------
/**
* Inserts a new <i>value</i> into my
* list, after the specified <i>before</i> element, and before the
* specified <i>after</i> element
*
* @return the newly created
* {@link org.apache.commons.collections.CursorableLinkedList.Listable}
*/
protected Listable insertListable(Listable before, Listable after, Object value) {
_modCount++;
_size++;
Listable elt = new Listable(before,after,value);
if(null != before) {
before.setNext(elt);
} else {
_head.setNext(elt);
}
if(null != after) {
after.setPrev(elt);
} else {
_head.setPrev(elt);
}
broadcastListableInserted(elt);
return elt;
}
/**
* Removes the given
* {@link org.apache.commons.collections.CursorableLinkedList.Listable}
* from my list.
*/
protected void removeListable(Listable elt) {
_modCount++;
_size--;
if(_head.next() == elt) {
_head.setNext(elt.next());
}
if(null != elt.next()) {
elt.next().setPrev(elt.prev());
}
if(_head.prev() == elt) {
_head.setPrev(elt.prev());
}
if(null != elt.prev()) {
elt.prev().setNext(elt.next());
}
broadcastListableRemoved(elt);
}
/**
* Returns the
* {@link org.apache.commons.collections.CursorableLinkedList.Listable}
* at the specified index.
*
* @throws IndexOutOfBoundsException if index is less than zero or
* greater than or equal to the size of this list.
*/
protected Listable getListableAt(int index) {
if(index < 0 || index >= _size) {
throw new IndexOutOfBoundsException(String.valueOf(index) + " < 0 or " + String.valueOf(index) + " >= " + _size);
}
if(index <=_size/2) {
Listable elt = _head.next();
for(int i = 0; i < index; i++) {
elt = elt.next();
}
return elt;
} else {
Listable elt = _head.prev();
for(int i = (_size-1); i > index; i--) {
elt = elt.prev();
}
return elt;
}
}
/**
* Registers a {@link CursorableLinkedList.Cursor} to be notified
* of changes to this list.
*/
protected void registerCursor(Cursor cur) {
// We take this opportunity to clean the _cursors list
// of WeakReference objects to garbage-collected cursors.
for (Iterator it = _cursors.iterator(); it.hasNext(); ) {
WeakReference ref = (WeakReference) it.next();
if (ref.get() == null) {
it.remove();
}
}
_cursors.add( new WeakReference(cur) );
}
/**
* Removes a {@link CursorableLinkedList.Cursor} from
* the set of cursors to be notified of changes to this list.
*/
protected void unregisterCursor(Cursor cur) {
for (Iterator it = _cursors.iterator(); it.hasNext(); ) {
WeakReference ref = (WeakReference) it.next();
Cursor cursor = (Cursor) ref.get();
if (cursor == null) {
// some other unrelated cursor object has been
// garbage-collected; let's take the opportunity to
// clean up the cursors list anyway..
it.remove();
} else if (cursor == cur) {
ref.clear();
it.remove();
break;
}
}
}
/**
* Informs all of my registered cursors that they are now
* invalid.
*/
protected void invalidateCursors() {
Iterator it = _cursors.iterator();
while (it.hasNext()) {
WeakReference ref = (WeakReference) it.next();
Cursor cursor = (Cursor) ref.get();
if (cursor != null) {
// cursor is null if object has been garbage-collected
cursor.invalidate();
ref.clear();
}
it.remove();
}
}
/**
* Informs all of my registered cursors that the specified
* element was changed.
* @see #set(int,java.lang.Object)
*/
protected void broadcastListableChanged(Listable elt) {
Iterator it = _cursors.iterator();
while (it.hasNext()) {
WeakReference ref = (WeakReference) it.next();
Cursor cursor = (Cursor) ref.get();
if (cursor == null) {
it.remove(); // clean up list
} else {
cursor.listableChanged(elt);
}
}
}
/**
* Informs all of my registered cursors that the specified
* element was just removed from my list.
*/
protected void broadcastListableRemoved(Listable elt) {
Iterator it = _cursors.iterator();
while (it.hasNext()) {
WeakReference ref = (WeakReference) it.next();
Cursor cursor = (Cursor) ref.get();
if (cursor == null) {
it.remove(); // clean up list
} else {
cursor.listableRemoved(elt);
}
}
}
/**
* Informs all of my registered cursors that the specified
* element was just added to my list.
*/
protected void broadcastListableInserted(Listable elt) {
Iterator it = _cursors.iterator();
while (it.hasNext()) {
WeakReference ref = (WeakReference) it.next();
Cursor cursor = (Cursor) ref.get();
if (cursor == null) {
it.remove(); // clean up list
} else {
cursor.listableInserted(elt);
}
}
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(_size);
Listable cur = _head.next();
while (cur != null) {
out.writeObject(cur.value());
cur = cur.next();
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
_size = 0;
_modCount = 0;
_cursors = new ArrayList();
_head = new Listable(null,null,null);
int size = in.readInt();
for (int i=0;i<size;i++) {
this.add(in.readObject());
}
}
//--- protected attributes ---------------------------------------
/** The number of elements in me. */
protected transient int _size = 0;
/**
* A sentry node.
* <p>
* <tt>_head.next()</tt> points to the first element in the list,
* <tt>_head.prev()</tt> to the last. Note that it is possible for
* <tt>_head.next().prev()</tt> and <tt>_head.prev().next()</tt> to be
* non-null, as when I am a sublist for some larger list.
* Use <tt>== _head.next()</tt> and <tt>== _head.prev()</tt> to determine
* if a given
* {@link org.apache.commons.collections.CursorableLinkedList.Listable}
* is the first or last element in the list.
*/
protected transient Listable _head = new Listable(null,null,null);
/** Tracks the number of structural modifications to me. */
protected transient int _modCount = 0;
/**
* A list of the currently {@link CursorableLinkedList.Cursor}s currently
* open in this list.
*/
protected transient List _cursors = new ArrayList();
//--- inner classes ----------------------------------------------
static class Listable implements Serializable {
private Listable _prev = null;
private Listable _next = null;
private Object _val = null;
Listable(Listable prev, Listable next, Object val) {
_prev = prev;
_next = next;
_val = val;
}
Listable next() {
return _next;
}
Listable prev() {
return _prev;
}
Object value() {
return _val;
}
void setNext(Listable next) {
_next = next;
}
void setPrev(Listable prev) {
_prev = prev;
}
Object setValue(Object val) {
Object temp = _val;
_val = val;
return temp;
}
}
class ListIter implements ListIterator {
Listable _cur = null;
Listable _lastReturned = null;
int _expectedModCount = _modCount;
int _nextIndex = 0;
ListIter(int index) {
if(index == 0) {
_cur = new Listable(null,_head.next(),null);
_nextIndex = 0;
} else if(index == _size) {
_cur = new Listable(_head.prev(),null,null);
_nextIndex = _size;
} else {
Listable temp = getListableAt(index);
_cur = new Listable(temp.prev(),temp,null);
_nextIndex = index;
}
}
public Object previous() {
checkForComod();
if(!hasPrevious()) {
throw new NoSuchElementException();
} else {
Object ret = _cur.prev().value();
_lastReturned = _cur.prev();
_cur.setNext(_cur.prev());
_cur.setPrev(_cur.prev().prev());
_nextIndex--;
return ret;
}
}
public boolean hasNext() {
checkForComod();
return(null != _cur.next() && _cur.prev() != _head.prev());
}
public Object next() {
checkForComod();
if(!hasNext()) {
throw new NoSuchElementException();
} else {
Object ret = _cur.next().value();
_lastReturned = _cur.next();
_cur.setPrev(_cur.next());
_cur.setNext(_cur.next().next());
_nextIndex++;
return ret;
}
}
public int previousIndex() {
checkForComod();
if(!hasPrevious()) {
return -1;
}
return _nextIndex-1;
}
public boolean hasPrevious() {
checkForComod();
return(null != _cur.prev() && _cur.next() != _head.next());
}
public void set(Object o) {
checkForComod();
try {
_lastReturned.setValue(o);
} catch(NullPointerException e) {
throw new IllegalStateException();
}
}
public int nextIndex() {
checkForComod();
if(!hasNext()) {
return size();
}
return _nextIndex;
}
public void remove() {
checkForComod();
if(null == _lastReturned) {
throw new IllegalStateException();
} else {
_cur.setNext(_lastReturned == _head.prev() ? null : _lastReturned.next());
_cur.setPrev(_lastReturned == _head.next() ? null : _lastReturned.prev());
removeListable(_lastReturned);
_lastReturned = null;
_nextIndex--;
_expectedModCount++;
}
}
public void add(Object o) {
checkForComod();
_cur.setPrev(insertListable(_cur.prev(),_cur.next(),o));
_lastReturned = null;
_nextIndex++;
_expectedModCount++;
}
protected void checkForComod() {
if(_expectedModCount != _modCount) {
throw new ConcurrentModificationException();
}
}
}
public class Cursor extends ListIter implements ListIterator {
boolean _valid = false;
Cursor(int index) {
super(index);
_valid = true;
registerCursor(this);
}
public int previousIndex() {
throw new UnsupportedOperationException();
}
public int nextIndex() {
throw new UnsupportedOperationException();
}
public void add(Object o) {
checkForComod();
Listable elt = insertListable(_cur.prev(),_cur.next(),o);
_cur.setPrev(elt);
_cur.setNext(elt.next());
_lastReturned = null;
_nextIndex++;
_expectedModCount++;
}
protected void listableRemoved(Listable elt) {
if(null == _head.prev()) {
_cur.setNext(null);
} else if(_cur.next() == elt) {
_cur.setNext(elt.next());
}
if(null == _head.next()) {
_cur.setPrev(null);
} else if(_cur.prev() == elt) {
_cur.setPrev(elt.prev());
}
if(_lastReturned == elt) {
_lastReturned = null;
}
}
protected void listableInserted(Listable elt) {
if(null == _cur.next() && null == _cur.prev()) {
_cur.setNext(elt);
} else if(_cur.prev() == elt.prev()) {
_cur.setNext(elt);
}
if(_cur.next() == elt.next()) {
_cur.setPrev(elt);
}
if(_lastReturned == elt) {
_lastReturned = null;
}
}
protected void listableChanged(Listable elt) {
if(_lastReturned == elt) {
_lastReturned = null;
}
}
protected void checkForComod() {
if(!_valid) {
throw new ConcurrentModificationException();
}
}
protected void invalidate() {
_valid = false;
}
/**
* Mark this cursor as no longer being needed. Any resources
* associated with this cursor are immediately released.
* In previous versions of this class, it was mandatory to close
* all cursor objects to avoid memory leaks. It is <i>no longer</i>
* necessary to call this close method; an instance of this class
* can now be treated exactly like a normal iterator.
*/
public void close() {
if(_valid) {
_valid = false;
unregisterCursor(this);
}
}
}
}
/**
* @deprecated Use new version in list subpackage, which has been rewritten
* and now returns the cursor from the listIterator method. Will be removed in v4.0
*/
class CursorableSubList extends CursorableLinkedList implements List {
//--- constructors -----------------------------------------------
CursorableSubList(CursorableLinkedList list, int from, int to) {
if(0 > from || list.size() < to) {
throw new IndexOutOfBoundsException();
} else if(from > to) {
throw new IllegalArgumentException();
}
_list = list;
if(from < list.size()) {
_head.setNext(_list.getListableAt(from));
_pre = (null == _head.next()) ? null : _head.next().prev();
} else {
_pre = _list.getListableAt(from-1);
}
if(from == to) {
_head.setNext(null);
_head.setPrev(null);
if(to < list.size()) {
_post = _list.getListableAt(to);
} else {
_post = null;
}
} else {
_head.setPrev(_list.getListableAt(to-1));
_post = _head.prev().next();
}
_size = to - from;
_modCount = _list._modCount;
}
//--- public methods ------------------------------------------
public void clear() {
checkForComod();
Iterator it = iterator();
while(it.hasNext()) {
it.next();
it.remove();
}
}
public Iterator iterator() {
checkForComod();
return super.iterator();
}
public int size() {
checkForComod();
return super.size();
}
public boolean isEmpty() {
checkForComod();
return super.isEmpty();
}
public Object[] toArray() {
checkForComod();
return super.toArray();
}
public Object[] toArray(Object a[]) {
checkForComod();
return super.toArray(a);
}
public boolean contains(Object o) {
checkForComod();
return super.contains(o);
}
public boolean remove(Object o) {
checkForComod();
return super.remove(o);
}
public Object removeFirst() {
checkForComod();
return super.removeFirst();
}
public Object removeLast() {
checkForComod();
return super.removeLast();
}
public boolean addAll(Collection c) {
checkForComod();
return super.addAll(c);
}
public boolean add(Object o) {
checkForComod();
return super.add(o);
}
public boolean addFirst(Object o) {
checkForComod();
return super.addFirst(o);
}
public boolean addLast(Object o) {
checkForComod();
return super.addLast(o);
}
public boolean removeAll(Collection c) {
checkForComod();
return super.removeAll(c);
}
public boolean containsAll(Collection c) {
checkForComod();
return super.containsAll(c);
}
public boolean addAll(int index, Collection c) {
checkForComod();
return super.addAll(index,c);
}
public int hashCode() {
checkForComod();
return super.hashCode();
}
public boolean retainAll(Collection c) {
checkForComod();
return super.retainAll(c);
}
public Object set(int index, Object element) {
checkForComod();
return super.set(index,element);
}
public boolean equals(Object o) {
checkForComod();
return super.equals(o);
}
public Object get(int index) {
checkForComod();
return super.get(index);
}
public Object getFirst() {
checkForComod();
return super.getFirst();
}
public Object getLast() {
checkForComod();
return super.getLast();
}
public void add(int index, Object element) {
checkForComod();
super.add(index,element);
}
public ListIterator listIterator(int index) {
checkForComod();
return super.listIterator(index);
}
public Object remove(int index) {
checkForComod();
return super.remove(index);
}
public int indexOf(Object o) {
checkForComod();
return super.indexOf(o);
}
public int lastIndexOf(Object o) {
checkForComod();
return super.lastIndexOf(o);
}
public ListIterator listIterator() {
checkForComod();
return super.listIterator();
}
public List subList(int fromIndex, int toIndex) {
checkForComod();
return super.subList(fromIndex,toIndex);
}
//--- protected methods ------------------------------------------
/**
* Inserts a new <i>value</i> into my
* list, after the specified <i>before</i> element, and before the
* specified <i>after</i> element
*
* @return the newly created {@link CursorableLinkedList.Listable}
*/
protected Listable insertListable(Listable before, Listable after, Object value) {
_modCount++;
_size++;
Listable elt = _list.insertListable((null == before ? _pre : before), (null == after ? _post : after),value);
if(null == _head.next()) {
_head.setNext(elt);
_head.setPrev(elt);
}
if(before == _head.prev()) {
_head.setPrev(elt);
}
if(after == _head.next()) {
_head.setNext(elt);
}
broadcastListableInserted(elt);
return elt;
}
/**
* Removes the given {@link CursorableLinkedList.Listable} from my list.
*/
protected void removeListable(Listable elt) {
_modCount++;
_size--;
if(_head.next() == elt && _head.prev() == elt) {
_head.setNext(null);
_head.setPrev(null);
}
if(_head.next() == elt) {
_head.setNext(elt.next());
}
if(_head.prev() == elt) {
_head.setPrev(elt.prev());
}
_list.removeListable(elt);
broadcastListableRemoved(elt);
}
/**
* Test to see if my underlying list has been modified
* by some other process. If it has, throws a
* {@link ConcurrentModificationException}, otherwise
* quietly returns.
*
* @throws ConcurrentModificationException
*/
protected void checkForComod() throws ConcurrentModificationException {
if(_modCount != _list._modCount) {
throw new ConcurrentModificationException();
}
}
//--- protected attributes ---------------------------------------
/** My underlying list */
protected CursorableLinkedList _list = null;
/** The element in my underlying list preceding the first element in my list. */
protected Listable _pre = null;
/** The element in my underlying list following the last element in my list. */
protected Listable _post = null;
}
The table below shows all metrics for CursorableLinkedList.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 239.00 | Number of blocks | |
| BLOCK_COMMENT | 24.00 | Number of block comment lines | |
| COMMENTS | 485.00 | Comment lines | |
| COMMENT_DENSITY | 0.76 | Comment density | |
| COMPARISONS | 156.00 | Number of comparison operators | |
| CYCLOMATIC | 255.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 66.00 | Comments in declarations | |
| DOC_COMMENT | 443.00 | Number of javadoc comment lines | |
| ELOC | 636.00 | Effective lines of code | |
| EXEC_COMMENTS | 6.00 | Comments in executable code | |
| EXITS | 58.00 | Procedure exits | |
| FUNCTIONS | 108.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 129.66 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 266.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 | 1.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 | 15.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 | 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 | 11.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 11.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 | 5.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 1.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 | 1.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 | 2.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 | 2.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 | 0.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 | 2.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 | 3.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 1.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 | 1.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 | 2.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 | 1468.00 | Number of lines in the source file | |
| LINE_COMMENT | 18.00 | Number of line comments | |
| LOC | 846.00 | Lines of code | |
| LOGICAL_LINES | 423.00 | Number of statements | |
| LOOPS | 28.00 | Number of loops | |
| NEST_DEPTH | 4.00 | Maximum nesting depth | |
| OPERANDS | 1635.00 | Number of operands | |
| OPERATORS | 3821.00 | Number of operators | |
| PARAMS | 82.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 5456.00 | Halstead program length | |
| PROGRAM_VOCAB | 431.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 184.00 | Number of return points from functions | |
| SIZE | 47770.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 372.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 59.00 | Number of unique operators | |
| WHITESPACE | 137.00 | Number of whitespace lines | |