Remove added inheritDoc tags again.

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/collections/trunk@1371946 13f79535-47bb-0310-9956-ffa450edef68

src/main/java/org/apache/commons/collections/keyvalue/AbstractMapEntryDecorator.java

@@ -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);
     }

src/main/java/org/apache/commons/collections/list/AbstractLinkedList.java

@@ -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();
     }

src/main/java/org/apache/commons/collections/list/AbstractListDecorator.java

@@ -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);
     }

src/main/java/org/apache/commons/collections/list/FixedSizeList.java

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

src/main/java/org/apache/commons/collections/list/PredicatedList.java

@@ -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);

src/main/java/org/apache/commons/collections/list/SynchronizedList.java

@@ -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);

src/main/java/org/apache/commons/collections/list/TransformedList.java

@@ -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);