Apache
/
commons-collections
mirror of https://github.com/apache/commons-collections.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove added inheritDoc tags again. 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/collections/trunk@1371946 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Thomas Neidhart 2012-08-11 13:13:12 +00:00
parent 56b7b77bab
commit 5122c2adf2
7 changed files with 0 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/org/apache/commons/collections/keyvalue/AbstractMapEntryDecorator.java
View File

@ -56,17 +56,14 @@ public abstract class AbstractMapEntryDecorator<K, V> implements Map.Entry<K, V>
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public K getKey() {
return entry.getKey();
}
/** {@inheritDoc} */
public V getValue() {
return entry.getValue();
}
/** {@inheritDoc} */
public V setValue(V object) {
return entry.setValue(object);
}

22
src/main/java/org/apache/commons/collections/list/AbstractLinkedList.java
View File

@ -100,17 +100,14 @@ public abstract class AbstractLinkedList<E> implements List<E> {
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public int size() {
return size;
}
/** {@inheritDoc} */
public boolean isEmpty() {
return (size() == 0);
}
/** {@inheritDoc} */
public E get(int index) {
Node<E> node = getNode(index, false);
return node.getValue();
@ -118,24 +115,20 @@ public abstract class AbstractLinkedList<E> implements List<E> {
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public Iterator<E> iterator() {
return listIterator();
}
/** {@inheritDoc} */
public ListIterator<E> listIterator() {
return new LinkedListIterator<E>(this, 0);
}
/** {@inheritDoc} */
public ListIterator<E> listIterator(int fromIndex) {
return new LinkedListIterator<E>(this, fromIndex);
}
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public int indexOf(Object value) {
int i = 0;
for (Node<E> node = header.next; node != header; node = node.next) {
@ -147,7 +140,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
return -1;
}
/** {@inheritDoc} */
public int lastIndexOf(Object value) {
int i = size - 1;
for (Node<E> node = header.previous; node != header; node = node.previous) {
@ -159,12 +151,10 @@ public abstract class AbstractLinkedList<E> implements List<E> {
return -1;
}
/** {@inheritDoc} */
public boolean contains(Object value) {
return indexOf(value) != -1;
}
/** {@inheritDoc} */
public boolean containsAll(Collection<?> coll) {
for (Object o : coll) {
if (!contains(o)) {
@ -176,12 +166,10 @@ public abstract class AbstractLinkedList<E> implements List<E> {
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public Object[] toArray() {
return toArray(new Object[size]);
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] array) {
// Extend the array if needed
@ -214,24 +202,20 @@ public abstract class AbstractLinkedList<E> implements List<E> {
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public boolean add(E value) {
addLast(value);
return true;
}
/** {@inheritDoc} */
public void add(int index, E value) {
Node<E> node = getNode(index, true);
addNodeBefore(node, value);
}
/** {@inheritDoc} */
public boolean addAll(Collection<? extends E> coll) {
return addAll(size, coll);
}
/** {@inheritDoc} */
public boolean addAll(int index, Collection<? extends E> coll) {
Node<E> node = getNode(index, true);
for (E e : coll) {
@ -242,7 +226,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public E remove(int index) {
Node<E> node = getNode(index, false);
E oldValue = node.getValue();
@ -250,7 +233,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
return oldValue;
}
/** {@inheritDoc} */
public boolean remove(Object value) {
for (Node<E> node = header.next; node != header; node = node.next) {
if (isEqualValue(node.getValue(), value)) {
@ -261,7 +243,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
return false;
}
/** {@inheritDoc} */
public boolean removeAll(Collection<?> coll) {
boolean modified = false;
Iterator<E> it = iterator();
@ -276,7 +257,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public boolean retainAll(Collection<?> coll) {
boolean modified = false;
Iterator<E> it = iterator();
@ -289,7 +269,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
return modified;
}
/** {@inheritDoc} */
public E set(int index, E value) {
Node<E> node = getNode(index, false);
E oldValue = node.getValue();
@ -297,7 +276,6 @@ public abstract class AbstractLinkedList<E> implements List<E> {
return oldValue;
}
/** {@inheritDoc} */
public void clear() {
removeAllNodes();
}

10
src/main/java/org/apache/commons/collections/list/AbstractListDecorator.java
View File

@ -67,52 +67,42 @@ public abstract class AbstractListDecorator<E> extends AbstractCollectionDecorat
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public void add(int index, E object) {
decorated().add(index, object);
}
/** {@inheritDoc} */
public boolean addAll(int index, Collection<? extends E> coll) {
return decorated().addAll(index, coll);
}
/** {@inheritDoc} */
public E get(int index) {
return decorated().get(index);
}
/** {@inheritDoc} */
public int indexOf(Object object) {
return decorated().indexOf(object);
}
/** {@inheritDoc} */
public int lastIndexOf(Object object) {
return decorated().lastIndexOf(object);
}
/** {@inheritDoc} */
public ListIterator<E> listIterator() {
return decorated().listIterator();
}
/** {@inheritDoc} */
public ListIterator<E> listIterator(int index) {
return decorated().listIterator(index);
}
/** {@inheritDoc} */
public E remove(int index) {
return decorated().remove(index);
}
/** {@inheritDoc} */
public E set(int index, E object) {
return decorated().set(index, object);
}
/** {@inheritDoc} */
public List<E> subList(int fromIndex, int toIndex) {
return decorated().subList(fromIndex, toIndex);
}

2
src/main/java/org/apache/commons/collections/list/FixedSizeList.java
View File

@ -170,12 +170,10 @@ public class FixedSizeList<E>
}
}
/** {@inheritDoc} */
public boolean isFull() {
return true;
}
/** {@inheritDoc} */
public int maxSize() {
return size();
}

10
src/main/java/org/apache/commons/collections/list/PredicatedList.java
View File

@ -90,35 +90,29 @@ public class PredicatedList<E> extends PredicatedCollection<E> implements List<E
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public E get(int index) {
return decorated().get(index);
}
/** {@inheritDoc} */
public int indexOf(Object object) {
return decorated().indexOf(object);
}
/** {@inheritDoc} */
public int lastIndexOf(Object object) {
return decorated().lastIndexOf(object);
}
/** {@inheritDoc} */
public E remove(int index) {
return decorated().remove(index);
}
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public void add(int index, E object) {
validate(object);
decorated().add(index, object);
}
/** {@inheritDoc} */
public boolean addAll(int index, Collection<? extends E> coll) {
for (E aColl : coll) {
validate(aColl);
@ -126,23 +120,19 @@ public class PredicatedList<E> extends PredicatedCollection<E> implements List<E
return decorated().addAll(index, coll);
}
/** {@inheritDoc} */
public ListIterator<E> listIterator() {
return listIterator(0);
}
/** {@inheritDoc} */
public ListIterator<E> listIterator(int i) {
return new PredicatedListIterator(decorated().listIterator(i));
}
/** {@inheritDoc} */
public E set(int index, E object) {
validate(object);
return decorated().set(index, object);
}
/** {@inheritDoc} */
public List<E> subList(int fromIndex, int toIndex) {
List<E> sub = decorated().subList(fromIndex, toIndex);
return new PredicatedList<E>(sub, predicate);

8
src/main/java/org/apache/commons/collections/list/SynchronizedList.java
View File

@ -83,35 +83,30 @@ public class SynchronizedList<E> extends SynchronizedCollection<E> implements Li
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public void add(int index, E object) {
synchronized (lock) {
getList().add(index, object);
}
}
/** {@inheritDoc} */
public boolean addAll(int index, Collection<? extends E> coll) {
synchronized (lock) {
return getList().addAll(index, coll);
}
}
/** {@inheritDoc} */
public E get(int index) {
synchronized (lock) {
return getList().get(index);
}
}
/** {@inheritDoc} */
public int indexOf(Object object) {
synchronized (lock) {
return getList().indexOf(object);
}
}
/** {@inheritDoc} */
public int lastIndexOf(Object object) {
synchronized (lock) {
return getList().lastIndexOf(object);
@ -147,21 +142,18 @@ public class SynchronizedList<E> extends SynchronizedCollection<E> implements Li
return getList().listIterator(index);
}
/** {@inheritDoc} */
public E remove(int index) {
synchronized (lock) {
return getList().remove(index);
}
}
/** {@inheritDoc} */
public E set(int index, E object) {
synchronized (lock) {
return getList().set(index, object);
}
}
/** {@inheritDoc} */
public List<E> subList(int fromIndex, int toIndex) {
synchronized (lock) {
List<E> list = getList().subList(fromIndex, toIndex);

10
src/main/java/org/apache/commons/collections/list/TransformedList.java
View File

@ -115,57 +115,47 @@ public class TransformedList<E> extends TransformedCollection<E> implements List
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public E get(int index) {
return getList().get(index);
}
/** {@inheritDoc} */
public int indexOf(Object object) {
return getList().indexOf(object);
}
/** {@inheritDoc} */
public int lastIndexOf(Object object) {
return getList().lastIndexOf(object);
}
/** {@inheritDoc} */
public E remove(int index) {
return getList().remove(index);
}
//-----------------------------------------------------------------------
/** {@inheritDoc} */
public void add(int index, E object) {
object = transform(object);
getList().add(index, object);
}
/** {@inheritDoc} */
public boolean addAll(int index, Collection<? extends E> coll) {
coll = transform(coll);
return getList().addAll(index, coll);
}
/** {@inheritDoc} */
public ListIterator<E> listIterator() {
return listIterator(0);
}
/** {@inheritDoc} */
public ListIterator<E> listIterator(int i) {
return new TransformedListIterator(getList().listIterator(i));
}
/** {@inheritDoc} */
public E set(int index, E object) {
object = transform(object);
return getList().set(index, object);
}
/** {@inheritDoc} */
public List<E> subList(int fromIndex, int toIndex) {
List<E> sub = getList().subList(fromIndex, toIndex);
return new TransformedList<E>(sub, transformer);