Yep, that was the plan, but it was a trivial fix (in repo >= r412990).
Just wondering how Mikhail/Stepan got it to build? It may be a
consequence of different compiler versions again since I did not see a
compiler error on the Eclipse compiler either.
Regards,
Tim
Geir Magnusson Jr wrote:
> If it isn't really quick, roll it back and let Nathan fix it...
>
> geir
>
> Tim Ellison wrote:
>> I see it too.
>>
>> Stepan / Mikhail, do you get build failures? Shouldn't we stop putting
>> in new code until this is resolved?
>>
>> I am happy to take a look at the error, and if it is not a quick fix I
>> think we can roll back Collections without trouble.
>>
>> Regards,
>> Tim
>>
>>
>> Geir Magnusson Jr wrote:
>>> and the beer flowed....
>>>
>>> Mark Hindess wrote:
>>>> This breaks the build. I'm getting:
>>>>
>>>> compile:
>>>> [javac] Compiling 1839 source files to
>>>> /pbuilder/tmp/Harmony.clean/build
>>>> [javac]
>>>> /pbuilder/tmp/Harmony.clean/modules/luni/src/main/java/java/util/Collections.java:1074:
>>>> name clash: add(java.lang.Object) in
>>>> java.util.Collections.UnmodifiableCollection<java.util.Map.Entry<K,V>> and
>>>> add(E) in java.util.Set<java.util.Map.Entry<K,V>> have the same erasure,
>>>> yet neither overrides the other
>>>> [javac] private static class UnmodifiableEntrySet<K, V>
>>>> extends UnmodifiableSet<Map.Entry<K, V>> {
>>>> [javac] ^
>>>>
>>>> w/sun 1.5 javac on linux.
>>>>
>>>> Regards,
>>>> Mark.
>>>>
>>>> On 9 June 2006 at 4:59, [EMAIL PROTECTED] wrote:
>>>>> Author: ndbeyer
>>>>> Date: Thu Jun 8 21:59:15 2006
>>>>> New Revision: 412928
>>>>>
>>>>> URL: http://svn.apache.org/viewvc?rev=412928&view=rev
>>>>> Log:
>>>>> Generification of methods.
>>>>>
>>>>> Modified:
>>>>>
>>>>> incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java
>>>>> /util/Collections.java
>>>>>
>>>>> Modified:
>>>>> incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/jav
>>>>> a/java/util/Collections.java
>>>>> URL:
>>>>> http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/m
>>>>> odules/luni/src/main/java/java/util/Collections.java?rev=412928&r1=412927&r2=
>>>>> 412928&view=diff
>>>>> =============================================================================
>>>>> =
>>>>> ---
>>>>> incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java
>>>>> /util/Collections.java (original)
>>>>> +++
>>>>> incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java
>>>>> /util/Collections.java Thu Jun 8 21:59:15 2006
>>>>> @@ -27,15 +27,15 @@
>>>>> */
>>>>> public class Collections {
>>>>>
>>>>> - private static final class CopiesList extends AbstractList implements
>>>>> + private static final class CopiesList<E> extends AbstractList<E> implem
>>>>> ents
>>>>> Serializable {
>>>>> private static final long serialVersionUID = 273909926839871180
>>>>> 0L;
>>>>>
>>>>> private final int n;
>>>>>
>>>>> - private final Object element;
>>>>> + private final E element;
>>>>>
>>>>> - CopiesList(int length, Object object) {
>>>>> + CopiesList(int length, E object) {
>>>>> if (length < 0) {
>>>>> throw new IllegalArgumentException();
>>>>> }
>>>>> @@ -51,7 +51,7 @@
>>>>> return n;
>>>>> }
>>>>>
>>>>> - public Object get(int location) {
>>>>> + public E get(int location) {
>>>>> if (0 <= location && location < n)
>>>>> return element;
>>>>> throw new IndexOutOfBoundsException();
>>>>> @@ -162,13 +162,13 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - private static final class SingletonSet extends AbstractSet implements
>>>>> + private static final class SingletonSet<E> extends AbstractSet<E> imple
>>>>> ments
>>>>> Serializable {
>>>>> private static final long serialVersionUID = 319368720755043167
>>>>> 9L;
>>>>>
>>>>> - final Object element;
>>>>> + final E element;
>>>>>
>>>>> - SingletonSet(Object object) {
>>>>> + SingletonSet(E object) {
>>>>> element = object;
>>>>> }
>>>>>
>>>>> @@ -180,15 +180,15 @@
>>>>> return 1;
>>>>> }
>>>>>
>>>>> - public Iterator iterator() {
>>>>> - return new Iterator() {
>>>>> + public Iterator<E> iterator() {
>>>>> + return new Iterator<E>() {
>>>>> boolean hasNext = true;
>>>>>
>>>>> public boolean hasNext() {
>>>>> return hasNext;
>>>>> }
>>>>>
>>>>> - public Object next() {
>>>>> + public E next() {
>>>>> if (hasNext) {
>>>>> hasNext = false;
>>>>> return element;
>>>>> @@ -203,13 +203,13 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - private static final class SingletonList extends AbstractList implement
>>>>> s
>>>>> + private static final class SingletonList<E> extends AbstractList<E> imp
>>>>> lements
>>>>> Serializable {
>>>>> private static final long serialVersionUID = 309373661874065295
>>>>> 1L;
>>>>>
>>>>> - final Object element;
>>>>> + final E element;
>>>>>
>>>>> - SingletonList(Object object) {
>>>>> + SingletonList(E object) {
>>>>> element = object;
>>>>> }
>>>>>
>>>>> @@ -217,7 +217,7 @@
>>>>> return element == null ? object == null : element.equal
>>>>> s(object);
>>>>> }
>>>>>
>>>>> - public Object get(int location) {
>>>>> + public E get(int location) {
>>>>> if (location == 0)
>>>>> return element;
>>>>> throw new IndexOutOfBoundsException();
>>>>> @@ -228,13 +228,14 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - private static final class SingletonMap extends AbstractMap implements
>>>>> + private static final class SingletonMap<K, V> extends AbstractMap<K, V>
>>>>> implements
>>>>> Serializable {
>>>>> private static final long serialVersionUID = -69797244772150529
>>>>> 11L;
>>>>>
>>>>> - final Object k, v;
>>>>> + final K k;
>>>>> + final V v;
>>>>>
>>>>> - SingletonMap(Object key, Object value) {
>>>>> + SingletonMap(K key, V value) {
>>>>> k = key;
>>>>> v = value;
>>>>> }
>>>>> @@ -247,7 +248,7 @@
>>>>> return v == null ? value == null : v.equals(value);
>>>>> }
>>>>>
>>>>> - public Object get(Object key) {
>>>>> + public V get(Object key) {
>>>>> if (containsKey(key))
>>>>> return v;
>>>>> return null;
>>>>> @@ -257,11 +258,11 @@
>>>>> return 1;
>>>>> }
>>>>>
>>>>> - public Set entrySet() {
>>>>> - return new AbstractSet() {
>>>>> + public Set<Map.Entry<K, V>> entrySet() {
>>>>> + return new AbstractSet<Map.Entry<K, V>>() {
>>>>> public boolean contains(Object object) {
>>>>> if (object instanceof Map.Entry) {
>>>>> - Map.Entry entry = (Map.Entry) o
>>>>> bject;
>>>>> + Map.Entry<?, ?> entry = (Map.En
>>>>> try) object;
>>>>> return containsKey(entry.getKey
>>>>> ())
>>>>> && containsValu
>>>>> e(entry.getValue());
>>>>> }
>>>>> @@ -272,27 +273,27 @@
>>>>> return 1;
>>>>> }
>>>>>
>>>>> - public Iterator iterator() {
>>>>> - return new Iterator() {
>>>>> + public Iterator<Map.Entry<K, V>> iterator() {
>>>>> + return new Iterator<Map.Entry<K, V>>()
>>>>> {
>>>>> boolean hasNext = true;
>>>>>
>>>>> public boolean hasNext() {
>>>>> return hasNext;
>>>>> }
>>>>>
>>>>> - public Object next() {
>>>>> + public Map.Entry<K, V> next() {
>>>>> if (hasNext) {
>>>>> hasNext = false
>>>>> ;
>>>>> - return new Map.
>>>>> Entry() {
>>>>> + return new Map.
>>>>> Entry<K, V>() {
>>>>> public
>>>>> boolean equals(Object object) {
>>>>>
>>>>> return contains(object);
>>>>> }
>>>>>
>>>>> - public
>>>>> Object getKey() {
>>>>> + public
>>>>> K getKey() {
>>>>>
>>>>> return k;
>>>>> }
>>>>>
>>>>> - public
>>>>> Object getValue() {
>>>>> + public
>>>>> V getValue() {
>>>>>
>>>>> return v;
>>>>> }
>>>>>
>>>>> @@ -301,7 +302,7 @@
>>>>>
>>>>> ^ (v == null ? 0 : v.hashCode());
>>>>> }
>>>>>
>>>>> - public
>>>>> Object setValue(Object value) {
>>>>> + public
>>>>> V setValue(V value) {
>>>>>
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>> };
>>>>> @@ -318,29 +319,29 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - static class SynchronizedCollection implements Collection, Serializable
>>>>> {
>>>>> + static class SynchronizedCollection<E> implements Collection<E>, Serial
>>>>> izable {
>>>>> private static final long serialVersionUID = 305399503209133509
>>>>> 3L;
>>>>>
>>>>> - final Collection c;
>>>>> + final Collection<E> c;
>>>>> final Object mutex;
>>>>>
>>>>> - SynchronizedCollection(Collection collection) {
>>>>> + SynchronizedCollection(Collection<E> collection) {
>>>>> c = collection;
>>>>> mutex = this;
>>>>> }
>>>>>
>>>>> - SynchronizedCollection(Collection collection, Object mutex) {
>>>>> + SynchronizedCollection(Collection<E> collection, Object mutex)
>>>>> {
>>>>> c = collection;
>>>>> this.mutex = mutex;
>>>>> }
>>>>>
>>>>> - public boolean add(Object object) {
>>>>> + public boolean add(E object) {
>>>>> synchronized (mutex) {
>>>>> return c.add(object);
>>>>> }
>>>>> }
>>>>>
>>>>> - public boolean addAll(Collection collection) {
>>>>> + public boolean addAll(Collection<? extends E> collection) {
>>>>> synchronized (mutex) {
>>>>> return c.addAll(collection);
>>>>> }
>>>>> @@ -358,7 +359,7 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public boolean containsAll(Collection collection) {
>>>>> + public boolean containsAll(Collection<?> collection) {
>>>>> synchronized (mutex) {
>>>>> return c.containsAll(collection);
>>>>> }
>>>>> @@ -370,7 +371,7 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public Iterator iterator() {
>>>>> + public Iterator<E> iterator() {
>>>>> synchronized (mutex) {
>>>>> return c.iterator();
>>>>> }
>>>>> @@ -382,13 +383,13 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public boolean removeAll(Collection collection) {
>>>>> + public boolean removeAll(Collection<?> collection) {
>>>>> synchronized (mutex) {
>>>>> return c.removeAll(collection);
>>>>> }
>>>>> }
>>>>>
>>>>> - public boolean retainAll(Collection collection) {
>>>>> + public boolean retainAll(Collection<?> collection) {
>>>>> synchronized (mutex) {
>>>>> return c.retainAll(collection);
>>>>> }
>>>>> @@ -412,7 +413,7 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object[] toArray(Object[] array) {
>>>>> + public <T> T[] toArray(T[] array) {
>>>>> synchronized (mutex) {
>>>>> return c.toArray(array);
>>>>> }
>>>>> @@ -425,21 +426,21 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - static class SynchronizedRandomAccessList extends SynchronizedList
>>>>> + static class SynchronizedRandomAccessList<E> extends SynchronizedList<E
>>>>> implements RandomAccess {
>>>>> private static final long serialVersionUID = 153067458360235848
>>>>> 2L;
>>>>>
>>>>> - SynchronizedRandomAccessList(List l) {
>>>>> + SynchronizedRandomAccessList(List<E> l) {
>>>>> super(l);
>>>>> }
>>>>>
>>>>> - SynchronizedRandomAccessList(List l, Object mutex) {
>>>>> + SynchronizedRandomAccessList(List<E> l, Object mutex) {
>>>>> super(l, mutex);
>>>>> }
>>>>>
>>>>> - public List subList(int start, int end) {
>>>>> + public List<E> subList(int start, int end) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedRandomAccessList(list
>>>>> + return new SynchronizedRandomAccessList<E>(list
>>>>> .subList(start, end), mutex);
>>>>> }
>>>>> }
>>>>> @@ -455,33 +456,33 @@
>>>>> * @see SynchronizedList#readResolve()
>>>>> */
>>>>> private Object writeReplace() {
>>>>> - return new SynchronizedList(list);
>>>>> + return new SynchronizedList<E>(list);
>>>>> }
>>>>> }
>>>>>
>>>>> - static class SynchronizedList extends SynchronizedCollection implements
>>>>> - List {
>>>>> + static class SynchronizedList<E> extends SynchronizedCollection<E> impl
>>>>> ements
>>>>> + List<E> {
>>>>> private static final long serialVersionUID = -77540903729629715
>>>>> 24L;
>>>>>
>>>>> - final List list;
>>>>> + final List<E> list;
>>>>>
>>>>> - SynchronizedList(List l) {
>>>>> + SynchronizedList(List<E> l) {
>>>>> super(l);
>>>>> list = l;
>>>>> }
>>>>>
>>>>> - SynchronizedList(List l, Object mutex) {
>>>>> + SynchronizedList(List<E> l, Object mutex) {
>>>>> super(l, mutex);
>>>>> list = l;
>>>>> }
>>>>>
>>>>> - public void add(int location, Object object) {
>>>>> + public void add(int location, E object) {
>>>>> synchronized (mutex) {
>>>>> list.add(location, object);
>>>>> }
>>>>> }
>>>>>
>>>>> - public boolean addAll(int location, Collection collection) {
>>>>> + public boolean addAll(int location, Collection<? extends E> col
>>>>> lection) {
>>>>> synchronized (mutex) {
>>>>> return list.addAll(location, collection);
>>>>> }
>>>>> @@ -493,7 +494,7 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object get(int location) {
>>>>> + public E get(int location) {
>>>>> synchronized (mutex) {
>>>>> return list.get(location);
>>>>> }
>>>>> @@ -517,33 +518,33 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public ListIterator listIterator() {
>>>>> + public ListIterator<E> listIterator() {
>>>>> synchronized (mutex) {
>>>>> return list.listIterator();
>>>>> }
>>>>> }
>>>>>
>>>>> - public ListIterator listIterator(int location) {
>>>>> + public ListIterator<E> listIterator(int location) {
>>>>> synchronized (mutex) {
>>>>> return list.listIterator(location);
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object remove(int location) {
>>>>> + public E remove(int location) {
>>>>> synchronized (mutex) {
>>>>> return list.remove(location);
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object set(int location, Object object) {
>>>>> + public E set(int location, E object) {
>>>>> synchronized (mutex) {
>>>>> return list.set(location, object);
>>>>> }
>>>>> }
>>>>>
>>>>> - public List subList(int start, int end) {
>>>>> + public List<E> subList(int start, int end) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedList(list.subList(start,
>>>>> end), mutex);
>>>>> + return new SynchronizedList<E>(list.subList(sta
>>>>> rt, end), mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -569,24 +570,24 @@
>>>>> */
>>>>> private Object readResolve() {
>>>>> if (list instanceof RandomAccess)
>>>>> - return new SynchronizedRandomAccessList(list, m
>>>>> utex);
>>>>> + return new SynchronizedRandomAccessList<E>(list
>>>>> , mutex);
>>>>> else
>>>>> return this;
>>>>> }
>>>>> }
>>>>>
>>>>> - static class SynchronizedMap implements Map, Serializable {
>>>>> + static class SynchronizedMap<K, V> implements Map<K, V>, Serializable {
>>>>> private static final long serialVersionUID = 197819847965902271
>>>>> 5L;
>>>>>
>>>>> - private final Map m;
>>>>> + private final Map<K, V> m;
>>>>> final Object mutex;
>>>>>
>>>>> - SynchronizedMap(Map map) {
>>>>> + SynchronizedMap(Map<K, V> map) {
>>>>> m = map;
>>>>> mutex = this;
>>>>> }
>>>>>
>>>>> - SynchronizedMap(Map map, Object mutex) {
>>>>> + SynchronizedMap(Map<K, V> map, Object mutex) {
>>>>> m = map;
>>>>> this.mutex = mutex;
>>>>> }
>>>>> @@ -609,9 +610,9 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public Set entrySet() {
>>>>> + public Set<Map.Entry<K, V>> entrySet() {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSet(m.entrySet(), mutex)
>>>>> ;
>>>>> + return new SynchronizedSet<Map.Entry<K, V>>(m.e
>>>>> ntrySet(), mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -621,7 +622,7 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object get(Object key) {
>>>>> + public V get(Object key) {
>>>>> synchronized (mutex) {
>>>>> return m.get(key);
>>>>> }
>>>>> @@ -639,25 +640,25 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public Set keySet() {
>>>>> + public Set<K> keySet() {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSet(m.keySet(), mutex);
>>>>> + return new SynchronizedSet<K>(m.keySet(), mutex
>>>>> );
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object put(Object key, Object value) {
>>>>> + public V put(K key, V value) {
>>>>> synchronized (mutex) {
>>>>> return m.put(key, value);
>>>>> }
>>>>> }
>>>>>
>>>>> - public void putAll(Map map) {
>>>>> + public void putAll(Map<? extends K, ? extends V> map) {
>>>>> synchronized (mutex) {
>>>>> m.putAll(map);
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object remove(Object key) {
>>>>> + public V remove(Object key) {
>>>>> synchronized (mutex) {
>>>>> return m.remove(key);
>>>>> }
>>>>> @@ -669,9 +670,9 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - public Collection values() {
>>>>> + public Collection<V> values() {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedCollection(m.values(), m
>>>>> utex);
>>>>> + return new SynchronizedCollection<V>(m.values()
>>>>> , mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -688,14 +689,14 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - static class SynchronizedSet extends SynchronizedCollection implements
>>>>> Set {
>>>>> + static class SynchronizedSet<E> extends SynchronizedCollection<E> imple
>>>>> ments Set<E> {
>>>>> private static final long serialVersionUID = 487447009682186044
>>>>> L;
>>>>>
>>>>> - SynchronizedSet(Set set) {
>>>>> + SynchronizedSet(Set<E> set) {
>>>>> super(set);
>>>>> }
>>>>>
>>>>> - SynchronizedSet(Set set, Object mutex) {
>>>>> + SynchronizedSet(Set<E> set, Object mutex) {
>>>>> super(set, mutex);
>>>>> }
>>>>>
>>>>> @@ -718,56 +719,56 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - static class SynchronizedSortedMap extends SynchronizedMap implements
>>>>> - SortedMap {
>>>>> + static class SynchronizedSortedMap<K, V> extends SynchronizedMap<K, V>
>>>>> implements
>>>>> + SortedMap<K, V> {
>>>>> private static final long serialVersionUID = -87981467694164837
>>>>> 93L;
>>>>>
>>>>> - private final SortedMap sm;
>>>>> + private final SortedMap<K, V> sm;
>>>>>
>>>>> - SynchronizedSortedMap(SortedMap map) {
>>>>> + SynchronizedSortedMap(SortedMap<K, V> map) {
>>>>> super(map);
>>>>> sm = map;
>>>>> }
>>>>>
>>>>> - SynchronizedSortedMap(SortedMap map, Object mutex) {
>>>>> + SynchronizedSortedMap(SortedMap<K, V> map, Object mutex) {
>>>>> super(map, mutex);
>>>>> sm = map;
>>>>> }
>>>>>
>>>>> - public Comparator comparator() {
>>>>> + public Comparator<? super K> comparator() {
>>>>> synchronized (mutex) {
>>>>> return sm.comparator();
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object firstKey() {
>>>>> + public K firstKey() {
>>>>> synchronized (mutex) {
>>>>> return sm.firstKey();
>>>>> }
>>>>> }
>>>>>
>>>>> - public SortedMap headMap(Object endKey) {
>>>>> + public SortedMap<K, V> headMap(K endKey) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSortedMap(sm.headMap(end
>>>>> Key), mutex);
>>>>> + return new SynchronizedSortedMap<K, V>(sm.headM
>>>>> ap(endKey), mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object lastKey() {
>>>>> + public K lastKey() {
>>>>> synchronized (mutex) {
>>>>> return sm.lastKey();
>>>>> }
>>>>> }
>>>>>
>>>>> - public SortedMap subMap(Object startKey, Object endKey) {
>>>>> + public SortedMap<K, V> subMap(K startKey, K endKey) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSortedMap(sm.subMap(star
>>>>> tKey, endKey),
>>>>> + return new SynchronizedSortedMap<K, V>(sm.subMa
>>>>> p(startKey, endKey),
>>>>> mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> - public SortedMap tailMap(Object startKey) {
>>>>> + public SortedMap<K, V> tailMap(K startKey) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSortedMap(sm.tailMap(sta
>>>>> rtKey), mutex);
>>>>> + return new SynchronizedSortedMap<K, V>(sm.tailM
>>>>> ap(startKey), mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -778,55 +779,55 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - static class SynchronizedSortedSet extends SynchronizedSet implements
>>>>> - SortedSet {
>>>>> + static class SynchronizedSortedSet<E> extends SynchronizedSet<E> implem
>>>>> ents
>>>>> + SortedSet<E> {
>>>>> private static final long serialVersionUID = 869580131086212740
>>>>> 6L;
>>>>>
>>>>> - private final SortedSet ss;
>>>>> + private final SortedSet<E> ss;
>>>>>
>>>>> - SynchronizedSortedSet(SortedSet set) {
>>>>> + SynchronizedSortedSet(SortedSet<E> set) {
>>>>> super(set);
>>>>> ss = set;
>>>>> }
>>>>>
>>>>> - SynchronizedSortedSet(SortedSet set, Object mutex) {
>>>>> + SynchronizedSortedSet(SortedSet<E> set, Object mutex) {
>>>>> super(set, mutex);
>>>>> ss = set;
>>>>> }
>>>>>
>>>>> - public Comparator comparator() {
>>>>> + public Comparator<? super E> comparator() {
>>>>> synchronized (mutex) {
>>>>> return ss.comparator();
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object first() {
>>>>> + public E first() {
>>>>> synchronized (mutex) {
>>>>> return ss.first();
>>>>> }
>>>>> }
>>>>>
>>>>> - public SortedSet headSet(Object end) {
>>>>> + public SortedSet<E> headSet(E end) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSortedSet(ss.headSet(end
>>>>> ), mutex);
>>>>> + return new SynchronizedSortedSet<E>(ss.headSet(
>>>>> end), mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> - public Object last() {
>>>>> + public E last() {
>>>>> synchronized (mutex) {
>>>>> return ss.last();
>>>>> }
>>>>> }
>>>>>
>>>>> - public SortedSet subSet(Object start, Object end) {
>>>>> + public SortedSet<E> subSet(E start, E end) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSortedSet(ss.subSet(star
>>>>> t, end), mutex);
>>>>> + return new SynchronizedSortedSet<E>(ss.subSet(s
>>>>> tart, end), mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> - public SortedSet tailSet(Object start) {
>>>>> + public SortedSet<E> tailSet(E start) {
>>>>> synchronized (mutex) {
>>>>> - return new SynchronizedSortedSet(ss.tailSet(sta
>>>>> rt), mutex);
>>>>> + return new SynchronizedSortedSet<E>(ss.tailSet(
>>>>> start), mutex);
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -837,13 +838,13 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - private static class UnmodifiableCollection implements Collection,
>>>>> + private static class UnmodifiableCollection<E> implements Collection<E>
>>>>> ,
>>>>> Serializable {
>>>>> private static final long serialVersionUID = 182001775257891407
>>>>> 8L;
>>>>>
>>>>> - final Collection c;
>>>>> + final Collection<E> c;
>>>>>
>>>>> - UnmodifiableCollection(Collection collection) {
>>>>> + UnmodifiableCollection(Collection<E> collection) {
>>>>> c = collection;
>>>>> }
>>>>>
>>>>> @@ -851,7 +852,7 @@
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public boolean addAll(Collection collection) {
>>>>> + public boolean addAll(Collection<? extends E> collection) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> @@ -863,7 +864,7 @@
>>>>> return c.contains(object);
>>>>> }
>>>>>
>>>>> - public boolean containsAll(Collection collection) {
>>>>> + public boolean containsAll(Collection<?> collection) {
>>>>> return c.containsAll(collection);
>>>>> }
>>>>>
>>>>> @@ -871,15 +872,15 @@
>>>>> return c.isEmpty();
>>>>> }
>>>>>
>>>>> - public Iterator iterator() {
>>>>> - return new Iterator() {
>>>>> - Iterator iterator = c.iterator();
>>>>> + public Iterator<E> iterator() {
>>>>> + return new Iterator<E>() {
>>>>> + Iterator<E> iterator = c.iterator();
>>>>>
>>>>> public boolean hasNext() {
>>>>> return iterator.hasNext();
>>>>> }
>>>>>
>>>>> - public Object next() {
>>>>> + public E next() {
>>>>> return iterator.next();
>>>>> }
>>>>>
>>>>> @@ -893,11 +894,11 @@
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public boolean removeAll(Collection collection) {
>>>>> + public boolean removeAll(Collection<?> collection) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public boolean retainAll(Collection collection) {
>>>>> + public boolean retainAll(Collection<?> collection) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> @@ -905,11 +906,11 @@
>>>>> return c.size();
>>>>> }
>>>>>
>>>>> - public java.lang.Object[] toArray() {
>>>>> + public Object[] toArray() {
>>>>> return c.toArray();
>>>>> }
>>>>>
>>>>> - public Object[] toArray(Object[] array) {
>>>>> + public <T> T[] toArray(T[] array) {
>>>>> return c.toArray(array);
>>>>> }
>>>>>
>>>>> @@ -918,16 +919,16 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - private static class UnmodifiableRandomAccessList extends UnmodifiableL
>>>>> ist
>>>>> + private static class UnmodifiableRandomAccessList<E> extends Unmodifiab
>>>>> leList<E>
>>>>> implements RandomAccess {
>>>>> private static final long serialVersionUID = -25423088369663820
>>>>> 01L;
>>>>>
>>>>> - UnmodifiableRandomAccessList(List l) {
>>>>> + UnmodifiableRandomAccessList(List<E> l) {
>>>>> super(l);
>>>>> }
>>>>>
>>>>> - public List subList(int start, int end) {
>>>>> - return new UnmodifiableRandomAccessList(list.subList(st
>>>>> art, end));
>>>>> + public List<E> subList(int start, int end) {
>>>>> + return new UnmodifiableRandomAccessList<E>(list.subList
>>>>> (start, end));
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -941,26 +942,26 @@
>>>>> * @see UnmodifiableList#readResolve()
>>>>> */
>>>>> private Object writeReplace() {
>>>>> - return new UnmodifiableList(list);
>>>>> + return new UnmodifiableList<E>(list);
>>>>> }
>>>>> }
>>>>>
>>>>> - private static class UnmodifiableList extends UnmodifiableCollection
>>>>> - implements List {
>>>>> + private static class UnmodifiableList<E> extends UnmodifiableCollection
>>>>> <E>
>>>>> + implements List<E> {
>>>>> private static final long serialVersionUID = -28396735606524772
>>>>> 8L;
>>>>>
>>>>> - final List list;
>>>>> + final List<E> list;
>>>>>
>>>>> - UnmodifiableList(List l) {
>>>>> + UnmodifiableList(List<E> l) {
>>>>> super(l);
>>>>> list = l;
>>>>> }
>>>>>
>>>>> - public void add(int location, Object object) {
>>>>> + public void add(int location, E object) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public boolean addAll(int location, Collection collection) {
>>>>> + public boolean addAll(int location, Collection<? extends E> col
>>>>> lection) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> @@ -968,7 +969,7 @@
>>>>> return list.equals(object);
>>>>> }
>>>>>
>>>>> - public Object get(int location) {
>>>>> + public E get(int location) {
>>>>> return list.get(location);
>>>>> }
>>>>>
>>>>> @@ -984,15 +985,15 @@
>>>>> return list.lastIndexOf(object);
>>>>> }
>>>>>
>>>>> - public ListIterator listIterator() {
>>>>> + public ListIterator<E> listIterator() {
>>>>> return listIterator(0);
>>>>> }
>>>>>
>>>>> - public ListIterator listIterator(final int location) {
>>>>> - return new ListIterator() {
>>>>> - ListIterator iterator = list.listIterator(locat
>>>>> ion);
>>>>> + public ListIterator<E> listIterator(final int location) {
>>>>> + return new ListIterator<E>() {
>>>>> + ListIterator<E> iterator = list.listIterator(lo
>>>>> cation);
>>>>>
>>>>> - public void add(Object object) {
>>>>> + public void add(E object) {
>>>>> throw new UnsupportedOperationException
>>>>> ();
>>>>> }
>>>>>
>>>>> @@ -1004,7 +1005,7 @@
>>>>> return iterator.hasPrevious();
>>>>> }
>>>>>
>>>>> - public Object next() {
>>>>> + public E next() {
>>>>> return iterator.next();
>>>>> }
>>>>>
>>>>> @@ -1012,7 +1013,7 @@
>>>>> return iterator.nextIndex();
>>>>> }
>>>>>
>>>>> - public Object previous() {
>>>>> + public E previous() {
>>>>> return iterator.previous();
>>>>> }
>>>>>
>>>>> @@ -1030,16 +1031,16 @@
>>>>> };
>>>>> }
>>>>>
>>>>> - public Object remove(int location) {
>>>>> + public E remove(int location) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public Object set(int location, Object object) {
>>>>> + public E set(int location, E object) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public List subList(int start, int end) {
>>>>> - return new UnmodifiableList(list.subList(start, end));
>>>>> + public List<E> subList(int start, int end) {
>>>>> + return new UnmodifiableList<E>(list.subList(start, end)
>>>>> );
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -1059,24 +1060,24 @@
>>>>> */
>>>>> private Object readResolve() {
>>>>> if (list instanceof RandomAccess)
>>>>> - return new UnmodifiableRandomAccessList(list);
>>>>> + return new UnmodifiableRandomAccessList<E>(list
>>>>> );
>>>>> else
>>>>> return this;
>>>>> }
>>>>> }
>>>>>
>>>>> - private static class UnmodifiableMap implements Map, Serializable {
>>>>> + private static class UnmodifiableMap<K, V> implements Map<K, V>, Serial
>>>>> izable {
>>>>> private static final long serialVersionUID = -10342347285742860
>>>>> 14L;
>>>>>
>>>>> - private final Map m;
>>>>> + private final Map<K, V> m;
>>>>>
>>>>> - private static class UnmodifiableEntrySet extends UnmodifiableS
>>>>> et {
>>>>> + private static class UnmodifiableEntrySet<K, V> extends Unmodif
>>>>> iableSet<Map.Entry<K, V>> {
>>>>> private static final long serialVersionUID = 7854390611
>>>>> 657943733L;
>>>>>
>>>>> - private static class UnmodifiableMapEntry implements Ma
>>>>> p.Entry {
>>>>> - Map.Entry mapEntry;
>>>>> + private static class UnmodifiableMapEntry<K, V> impleme
>>>>> nts Map.Entry<K, V> {
>>>>> + Map.Entry<K, V> mapEntry;
>>>>>
>>>>> - UnmodifiableMapEntry(Map.Entry entry) {
>>>>> + UnmodifiableMapEntry(Map.Entry<K, V> entry) {
>>>>> mapEntry = entry;
>>>>> }
>>>>>
>>>>> @@ -1084,11 +1085,11 @@
>>>>> return mapEntry.equals(object);
>>>>> }
>>>>>
>>>>> - public Object getKey() {
>>>>> + public K getKey() {
>>>>> return mapEntry.getKey();
>>>>> }
>>>>>
>>>>> - public Object getValue() {
>>>>> + public V getValue() {
>>>>> return mapEntry.getValue();
>>>>> }
>>>>>
>>>>> @@ -1096,7 +1097,7 @@
>>>>> return mapEntry.hashCode();
>>>>> }
>>>>>
>>>>> - public Object setValue(Object object) {
>>>>> + public V setValue(V object) {
>>>>> throw new UnsupportedOperationException
>>>>> ();
>>>>> }
>>>>>
>>>>> @@ -1105,21 +1106,20 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - UnmodifiableEntrySet(Set set) {
>>>>> + UnmodifiableEntrySet(Set<Map.Entry<K, V>> set) {
>>>>> super(set);
>>>>> }
>>>>>
>>>>> - public Iterator iterator() {
>>>>> - return new Iterator() {
>>>>> - Iterator iterator = c.iterator();
>>>>> + public Iterator<Map.Entry<K, V>> iterator() {
>>>>> + return new Iterator<Map.Entry<K, V>>() {
>>>>> + Iterator<Map.Entry<K, V>> iterator = c.
>>>>> iterator();
>>>>>
>>>>> public boolean hasNext() {
>>>>> return iterator.hasNext();
>>>>> }
>>>>>
>>>>> - public Object next() {
>>>>> - return new UnmodifiableMapEntry
>>>>> ((Map.Entry) iterator
>>>>> - .next());
>>>>> + public Map.Entry<K, V> next() {
>>>>> + return new UnmodifiableMapEntry
>>>>> <K, V>(iterator.next());
>>>>> }
>>>>>
>>>>> public void remove() {
>>>>> @@ -1131,27 +1131,30 @@
>>>>> public Object[] toArray() {
>>>>> int length = c.size();
>>>>> Object[] result = new Object[length];
>>>>> - Iterator it = iterator();
>>>>> + Iterator<?> it = iterator();
>>>>> for (int i = length; --i >= 0;)
>>>>> result[i] = it.next();
>>>>> return result;
>>>>> }
>>>>>
>>>>> - public Object[] toArray(Object[] contents) {
>>>>> + public <T> T[] toArray(T[] contents) {
>>>>> int size = c.size(), index = 0;
>>>>> - Iterator it = iterator();
>>>>> - if (size > contents.length)
>>>>> - contents = (Object[]) Array.newInstance
>>>>> (contents.getClass()
>>>>> - .getComponentType(), si
>>>>> ze);
>>>>> - while (index < size)
>>>>> - contents[index++] = it.next();
>>>>> - if (index < contents.length)
>>>>> + Iterator<Map.Entry<K, V>> it = iterator();
>>>>> + if (size > contents.length) {
>>>>> + Class<?> ct = contents.getClass().getComponentType();
>>>>> + contents = (T[])Array.newInstance(ct, s
>>>>> ize);
>>>>> + }
>>>>> + while (index < size) {
>>>>> + contents[index++] = (T)it.next();
>>>>> + }
>>>>> + if (index < contents.length) {
>>>>> contents[index] = null;
>>>>> + }
>>>>> return contents;
>>>>> }
>>>>> }
>>>>>
>>>>> - UnmodifiableMap(Map map) {
>>>>> + UnmodifiableMap(Map<K, V> map) {
>>>>> m = map;
>>>>> }
>>>>>
>>>>> @@ -1167,15 +1170,15 @@
>>>>> return m.containsValue(value);
>>>>> }
>>>>>
>>>>> - public Set entrySet() {
>>>>> - return new UnmodifiableEntrySet(m.entrySet());
>>>>> + public Set<Map.Entry<K, V>> entrySet() {
>>>>> + return new UnmodifiableEntrySet<K, V>(m.entrySet());
>>>>> }
>>>>>
>>>>> public boolean equals(Object object) {
>>>>> return m.equals(object);
>>>>> }
>>>>>
>>>>> - public Object get(Object key) {
>>>>> + public V get(Object key) {
>>>>> return m.get(key);
>>>>> }
>>>>>
>>>>> @@ -1187,19 +1190,19 @@
>>>>> return m.isEmpty();
>>>>> }
>>>>>
>>>>> - public Set keySet() {
>>>>> - return new UnmodifiableSet(m.keySet());
>>>>> + public Set<K> keySet() {
>>>>> + return new UnmodifiableSet<K>(m.keySet());
>>>>> }
>>>>>
>>>>> - public Object put(Object key, Object value) {
>>>>> + public V put(K key, V value) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public void putAll(Map map) {
>>>>> + public void putAll(Map<? extends K, ? extends V> map) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> - public Object remove(Object key) {
>>>>> + public V remove(Object key) {
>>>>> throw new UnsupportedOperationException();
>>>>> }
>>>>>
>>>>> @@ -1207,20 +1210,20 @@
>>>>> return m.size();
>>>>> }
>>>>>
>>>>> - public Collection values() {
>>>>> - return new UnmodifiableCollection(m.values());
>>>>> + public Collection<V> values() {
>>>>> + return new UnmodifiableCollection<V>(m.values());
>>>>> }
>>>>>
>>>>> - public String toString() {
>>>>> - return m.toString();
>>>>> - }
>>>>> + public String toString() {
>>>>> + return m.toString();
>>>>> + }
>>>>> }
>>>>>
>>>>> - private static class UnmodifiableSet extends UnmodifiableCollection
>>>>> - implements Set {
>>>>> + private static class UnmodifiableSet<E> extends UnmodifiableCollection<
>>>>> E>
>>>>> + implements Set<E> {
>>>>> private static final long serialVersionUID = -92150478337750138
>>>>> 03L;
>>>>>
>>>>> - UnmodifiableSet(Set set) {
>>>>> + UnmodifiableSet(Set<E> set) {
>>>>> super(set);
>>>>> }
>>>>>
>>>>> @@ -1233,75 +1236,75 @@
>>>>> }
>>>>> }
>>>>>
>>>>> - private static class UnmodifiableSortedMap extends UnmodifiableMap
>>>>> - implements SortedMap {
>>>>> + private static class UnmodifiableSortedMap<K, V> extends UnmodifiableMa
>>>>> p<K, V>
>>>>> + implements SortedMap<K, V> {
>>>>> private static final long serialVersionUID = -88067438159967132
>>>>> 06L;
>>>>>
>>>>> - private final SortedMap sm;
>>>>> + private final SortedMap<K, V> sm;
>>>>>
>>>>> - UnmodifiableSortedMap(SortedMap map) {
>>>>> + UnmodifiableSortedMap(SortedMap<K, V> map) {
>>>>> super(map);
>>>>> sm = map;
>>>>> }
>>>>>
>>>>> - public Comparator comparator() {
>>>>> + public Comparator<? super K> comparator() {
>>>>> return sm.comparator();
>>>>> }
>>>>>
>>>>> - public Object firstKey() {
>>>>> + public K firstKey() {
>>>>> return sm.firstKey();
>>>>> }
>>>>>
>>>>> - public SortedMap headMap(Object before) {
>>>>> - return new UnmodifiableSortedMap(sm.headMap(before));
>>>>> + public SortedMap<K, V> headMap(K before) {
>>>>> + return new UnmodifiableSortedMap<K, V>(sm.headMap(befor
>>>>> e));
>>>>> }
>>>>>
>>>>> - public Object lastKey() {
>>>>> + public K lastKey() {
>>>>> return sm.lastKey();
>>>>> }
>>>>>
>>>>> - public SortedMap subMap(Object start, Object end) {
>>>>> - return new UnmodifiableSortedMap(sm.subMap(start, end))
>>>>> ;
>>>>> + public SortedMap<K, V> subMap(K start, K end) {
>>>>> + return new UnmodifiableSortedMap<K, V>(sm.subMap(start,
>>>>> end));
>>>>> }
>>>>>
>>>>> - public SortedMap tailMap(Object after) {
>>>>> - return new UnmodifiableSortedMap(sm.tailMap(after));
>>>>> + public SortedMap<K, V> tailMap(K after) {
>>>>> + return new UnmodifiableSortedMap<K, V>(sm.tailMap(after
>>>>> ));
>>>>> }
>>>>> }
>>>>>
>>>>> - private static class UnmodifiableSortedSet extends UnmodifiableSet
>>>>> - implements SortedSet {
>>>>> + private static class UnmodifiableSortedSet<E> extends UnmodifiableSet<E
>>>>> + implements SortedSet<E> {
>>>>> private static final long serialVersionUID = -49291495915999111
>>>>> 65L;
>>>>>
>>>>> - private final SortedSet ss;
>>>>> + private final SortedSet<E> ss;
>>>>>
>>>>> - UnmodifiableSortedSet(SortedSet set) {
>>>>> + UnmodifiableSortedSet(SortedSet<E> set) {
>>>>> super(set);
>>>>> ss = set;
>>>>> }
>>>>>
>>>>> - public Comparator comparator() {
>>>>> + public Comparator<? super E> comparator() {
>>>>> return ss.comparator();
>>>>> }
>>>>>
>>>>> - public Object first() {
>>>>> + public E first() {
>>>>> return ss.first();
>>>>> }
>>>>>
>>>>> - public SortedSet headSet(Object before) {
>>>>> - return new UnmodifiableSortedSet(ss.headSet(before));
>>>>> + public SortedSet<E> headSet(E before) {
>>>>> + return new UnmodifiableSortedSet<E>(ss.headSet(before))
>>>>> ;
>>>>> }
>>>>>
>>>>> - public Object last() {
>>>>> + public E last() {
>>>>> return ss.last();
>>>>> }
>>>>>
>>>>> - public SortedSet subSet(Object start, Object end) {
>>>>> - return new UnmodifiableSortedSet(ss.subSet(start, end))
>>>>> ;
>>>>> + public SortedSet<E> subSet(E start, E end) {
>>>>> + return new UnmodifiableSortedSet<E>(ss.subSet(start, en
>>>>> d));
>>>>> }
>>>>>
>>>>> - public SortedSet tailSet(Object after) {
>>>>> - return new UnmodifiableSortedSet(ss.tailSet(after));
>>>>> + public SortedSet<E> tailSet(E after) {
>>>>> + return new UnmodifiableSortedSet<E>(ss.tailSet(after));
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -1327,7 +1330,7 @@
>>>>> public static <T> int binarySearch(List<? extends Comparable<? super T>
>>>>>> list, T object) {
>>>>> if (list == null)
>>>>> throw new NullPointerException();
>>>>> - Comparable key = (Comparable) object;
>>>>> + Comparable key = (Comparable)object;
>>>>> if (!(list instanceof RandomAccess)) {
>>>>> ListIterator it = list.listIterator();
>>>>> while (it.hasNext()) {
>>>>> @@ -1414,12 +1417,12 @@
>>>>> * when replacing an element in the destination list is
>>>>> not
>>>>> * supported
>>>>> */
>>>>> - public static void copy(List destination, List source) {
>>>>> + public static <T> void copy(List<? super T> destination, List<? extends
>>>>> T> source) {
>>>>> if (destination.size() < source.size()) {
>>>>> throw new ArrayIndexOutOfBoundsException();
>>>>> }
>>>>> - Iterator srcIt = source.iterator();
>>>>> - ListIterator destIt = destination.listIterator();
>>>>> + Iterator<? extends T> srcIt = source.iterator();
>>>>> + ListIterator<? super T> destIt = destination.listIterator();
>>>>> while (srcIt.hasNext()) {
>>>>> try {
>>>>> destIt.next();
>>>>> @@ -1464,7 +1467,7 @@
>>>>> * when replacing an element in the List is not supporte
>>>>> d
>>>>> */
>>>>> public static <T> void fill(List<? super T> list, T object) {
>>>>> - ListIterator it = list.listIterator();
>>>>> + ListIterator<? super T> it = list.listIterator();
>>>>> while (it.hasNext()) {
>>>>> it.next();
>>>>> it.set(object);
>>>>> @@ -1578,8 +1581,8 @@
>>>>> * @exception IllegalArgumentException
>>>>> * when <code>length < 0</code>
>>>>> */
>>>>> - public static List nCopies(final int length, Object object) {
>>>>> - return new CopiesList(length, object);
>>>>> + public static <T> List<T> nCopies(final int length, T object) {
>>>>> + return new CopiesList<T>(length, object);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -1592,7 +1595,7 @@
>>>>> * @exception UnsupportedOperationException
>>>>> * when replacing an element in the List is not supporte
>>>>> d
>>>>> */
>>>>> - public static void reverse(List list) {
>>>>> + public static void reverse(List<?> list) {
>>>>> int size = list.size();
>>>>> ListIterator front = list.listIterator();
>>>>> ListIterator back = list.listIterator(size);
>>>>> @@ -1615,7 +1618,7 @@
>>>>> * @see Comparable
>>>>> * @see Serializable
>>>>> */
>>>>> - public static Comparator reverseOrder() {
>>>>> + public static <T> Comparator<T> reverseOrder() {
>>>>> return new ReverseComparator();
>>>>> }
>>>>>
>>>>> @@ -1637,7 +1640,7 @@
>>>>> * @see Comparator
>>>>> * @since 1.5
>>>>> */
>>>>> - public static Comparator reverseOrder(Comparator c) {
>>>>> + public static <T> Comparator<T> reverseOrder(Comparator<T> c) {
>>>>> if (c == null)
>>>>> return reverseOrder();
>>>>> return new ReverseComparatorWithComparator(c);
>>>>> @@ -1652,7 +1655,7 @@
>>>>> * @exception UnsupportedOperationException
>>>>> * when replacing an element in the List is not supporte
>>>>> d
>>>>> */
>>>>> - public static void shuffle(List list) {
>>>>> + public static void shuffle(List<?> list) {
>>>>> shuffle(list, new Random());
>>>>> }
>>>>>
>>>>> @@ -1668,7 +1671,7 @@
>>>>> * @exception UnsupportedOperationException
>>>>> * when replacing an element in the List is not supporte
>>>>> d
>>>>> */
>>>>> - public static void shuffle(List list, Random random) {
>>>>> + public static void shuffle(List<?> list, Random random) {
>>>>> if (!(list instanceof RandomAccess)) {
>>>>> Object[] array = list.toArray();
>>>>> for (int i = array.length - 1; i > 0; i--) {
>>>>> @@ -1687,11 +1690,12 @@
>>>>> it.set(array[i++]);
>>>>> }
>>>>> } else {
>>>>> - for (int i = list.size() - 1; i > 0; i--) {
>>>>> + List rawList = list;
>>>>> + for (int i = rawList.size() - 1; i > 0; i--) {
>>>>> int index = random.nextInt() % (i + 1);
>>>>> if (index < 0)
>>>>> index = -index;
>>>>> - list.set(index, list.set(i, list.get(index)));
>>>>> + rawList.set(index, rawList.set(i, rawList.get(i
>>>>> ndex)));
>>>>> }
>>>>> }
>>>>> }
>>>>> @@ -1704,8 +1708,8 @@
>>>>> * the element
>>>>> * @return a Set containing the element
>>>>> */
>>>>> - public static Set singleton(Object object) {
>>>>> - return new SingletonSet(object);
>>>>> + public static <E> Set<E> singleton(E object) {
>>>>> + return new SingletonSet<E>(object);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -1716,8 +1720,8 @@
>>>>> * the element
>>>>> * @return a List containing the element
>>>>> */
>>>>> - public static List singletonList(Object object) {
>>>>> - return new SingletonList(object);
>>>>> + public static <E> List<E> singletonList(E object) {
>>>>> + return new SingletonList<E>(object);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -1730,8 +1734,8 @@
>>>>> * the value
>>>>> * @return a Map containing the key and value
>>>>> */
>>>>> - public static Map singletonMap(Object key, Object value) {
>>>>> - return new SingletonMap(key, value);
>>>>> + public static <K, V> Map<K, V> singletonMap(K key, V value) {
>>>>> + return new SingletonMap<K, V>(key, value);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -1744,14 +1748,14 @@
>>>>> * when an element in the List does not implement Compar
>>>>> able
>>>>> * or elements cannot be compared to each other
>>>>> */
>>>>> - public static void sort(List list) {
>>>>> + public static <T extends Comparable<? super T>> void sort(List<T> list)
>>>>> {
>>>>> Object[] array = list.toArray();
>>>>> Arrays.sort(array);
>>>>> int i = 0;
>>>>> - ListIterator it = list.listIterator();
>>>>> + ListIterator<T> it = list.listIterator();
>>>>> while (it.hasNext()) {
>>>>> it.next();
>>>>> - it.set(array[i++]);
>>>>> + it.set((T)array[i++]);
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -1767,14 +1771,14 @@
>>>>> * when elements in the List cannot be compared to each
>>>>> other
>>>>> * using the Comparator
>>>>> */
>>>>> - public static void sort(List list, Comparator comparator) {
>>>>> + public static <T> void sort(List<T> list, Comparator<? super T> compara
>>>>> tor) {
>>>>> Object[] array = list.toArray();
>>>>> - Arrays.sort(array, comparator);
>>>>> + Arrays.sort(array, (Comparator<Object>)comparator);
>>>>> int i = 0;
>>>>> - ListIterator it = list.listIterator();
>>>>> + ListIterator<T> it = list.listIterator();
>>>>> while (it.hasNext()) {
>>>>> it.next();
>>>>> - it.set(array[i++]);
>>>>> + it.set((T)array[i++]);
>>>>> }
>>>>> }
>>>>>
>>>>> @@ -1793,12 +1797,13 @@
>>>>> * @exception IndexOutOfBoundsException
>>>>> * if index1 or index2 is out of range of this list
>>>>> */
>>>>> - public static void swap(List list, int index1, int index2) {
>>>>> + public static void swap(List<?> list, int index1, int index2) {
>>>>> if (list == null)
>>>>> throw new NullPointerException();
>>>>> if (index1 == index2)
>>>>> return;
>>>>> - list.set(index2, list.set(index1, list.get(index2)));
>>>>> + List rawList = list;
>>>>> + rawList.set(index2, rawList.set(index1, rawList.get(index2)));
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -1820,7 +1825,7 @@
>>>>> * @exception UnsupportedOperationException
>>>>> * if the list does not support setting elements
>>>>> */
>>>>> - public static boolean replaceAll(List list, Object obj, Object obj2) {
>>>>> + public static <T> boolean replaceAll(List<T> list, T obj, T obj2) {
>>>>> int index;
>>>>> boolean found = false;
>>>>>
>>>>> @@ -1843,7 +1848,8 @@
>>>>> * It can be any integer: 0, positive, negative, larger than
>>>>> the
>>>>> * list size
>>>>> */
>>>>> - public static void rotate(List list, int dist) {
>>>>> + public static void rotate(List<?> lst, int dist) {
>>>>> + List list = lst;
>>>>> int size = list.size();
>>>>>
>>>>> // Can't sensibly rotate an empty collection
>>>>> @@ -1898,7 +1904,7 @@
>>>>> * @return the beginning index of the first occurrence of
>>>>> * <code>sublist</code> in <code>list</code>, or -1
>>>>> */
>>>>> - public static int indexOfSubList(List list, List sublist) {
>>>>> + public static int indexOfSubList(List<?> list, List<?> sublist) {
>>>>> int size = list.size();
>>>>> int sublistSize = sublist.size();
>>>>>
>>>>> @@ -1963,7 +1969,7 @@
>>>>> * @return the beginning index of the last occurrence of <code>sublist<
>>>>> /code>
>>>>> * in <code>list</code>, or -1
>>>>> */
>>>>> - public static int lastIndexOfSubList(List list, List sublist) {
>>>>> + public static int lastIndexOfSubList(List<?> list, List<?> sublist) {
>>>>> int sublistSize = sublist.size();
>>>>> int size = list.size();
>>>>>
>>>>> @@ -2020,8 +2026,8 @@
>>>>> * Enumeration
>>>>> * @return and ArrayList
>>>>> */
>>>>> - public static ArrayList list(Enumeration enumeration) {
>>>>> - ArrayList list = new ArrayList();
>>>>> + public static <T> ArrayList<T> list(Enumeration<T> enumeration) {
>>>>> + ArrayList<T> list = new ArrayList<T>();
>>>>> while (enumeration.hasMoreElements()) {
>>>>> list.add(enumeration.nextElement());
>>>>> }
>>>>> @@ -2036,10 +2042,10 @@
>>>>> * the Collection
>>>>> * @return a synchronized Collection
>>>>> */
>>>>> - public static Collection synchronizedCollection(Collection collection)
>>>>> {
>>>>> + public static <T> Collection<T> synchronizedCollection(Collection<T> co
>>>>> llection) {
>>>>> if (collection == null)
>>>>> throw new NullPointerException();
>>>>> - return new SynchronizedCollection(collection);
>>>>> + return new SynchronizedCollection<T>(collection);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2050,13 +2056,13 @@
>>>>> * the List
>>>>> * @return a synchronized List
>>>>> */
>>>>> - public static List synchronizedList(List list) {
>>>>> + public static <T> List<T> synchronizedList(List<T> list) {
>>>>> if (list == null)
>>>>> throw new NullPointerException();
>>>>> if (list instanceof RandomAccess)
>>>>> - return new SynchronizedRandomAccessList(list);
>>>>> + return new SynchronizedRandomAccessList<T>(list);
>>>>> else
>>>>> - return new SynchronizedList(list);
>>>>> + return new SynchronizedList<T>(list);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2067,10 +2073,10 @@
>>>>> * the Map
>>>>> * @return a synchronized Map
>>>>> */
>>>>> - public static Map synchronizedMap(Map map) {
>>>>> + public static <K, V> Map<K, V> synchronizedMap(Map<K, V> map) {
>>>>> if (map == null)
>>>>> throw new NullPointerException();
>>>>> - return new SynchronizedMap(map);
>>>>> + return new SynchronizedMap<K, V>(map);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2081,10 +2087,10 @@
>>>>> * the Set
>>>>> * @return a synchronized Set
>>>>> */
>>>>> - public static Set synchronizedSet(Set set) {
>>>>> + public static <E> Set<E> synchronizedSet(Set<E> set) {
>>>>> if (set == null)
>>>>> throw new NullPointerException();
>>>>> - return new SynchronizedSet(set);
>>>>> + return new SynchronizedSet<E>(set);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2095,10 +2101,10 @@
>>>>> * the SortedMap
>>>>> * @return a synchronized SortedMap
>>>>> */
>>>>> - public static SortedMap synchronizedSortedMap(SortedMap map) {
>>>>> + public static <K, V> SortedMap<K, V> synchronizedSortedMap(SortedMap<K,
>>>>> V> map) {
>>>>> if (map == null)
>>>>> throw new NullPointerException();
>>>>> - return new SynchronizedSortedMap(map);
>>>>> + return new SynchronizedSortedMap<K, V>(map);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2109,10 +2115,10 @@
>>>>> * the SortedSet
>>>>> * @return a synchronized SortedSet
>>>>> */
>>>>> - public static SortedSet synchronizedSortedSet(SortedSet set) {
>>>>> + public static <E> SortedSet<E> synchronizedSortedSet(SortedSet<E> set)
>>>>> {
>>>>> if (set == null)
>>>>> throw new NullPointerException();
>>>>> - return new SynchronizedSortedSet(set);
>>>>> + return new SynchronizedSortedSet<E>(set);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2124,10 +2130,10 @@
>>>>> * the Collection
>>>>> * @return an unmodifiable Collection
>>>>> */
>>>>> - public static Collection unmodifiableCollection(Collection collection)
>>>>> {
>>>>> + public static <E> Collection<E> unmodifiableCollection(Collection<E> co
>>>>> llection) {
>>>>> if (collection == null)
>>>>> throw new NullPointerException();
>>>>> - return new UnmodifiableCollection(collection);
>>>>> + return new UnmodifiableCollection<E>(collection);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2139,13 +2145,13 @@
>>>>> * the List
>>>>> * @return an unmodifiable List
>>>>> */
>>>>> - public static List unmodifiableList(List list) {
>>>>> + public static <E> List<E> unmodifiableList(List<E> list) {
>>>>> if (list == null)
>>>>> throw new NullPointerException();
>>>>> if (list instanceof RandomAccess)
>>>>> - return new UnmodifiableRandomAccessList(list);
>>>>> + return new UnmodifiableRandomAccessList<E>(list);
>>>>> else
>>>>> - return new UnmodifiableList(list);
>>>>> + return new UnmodifiableList<E>(list);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2157,10 +2163,10 @@
>>>>> * the Map
>>>>> * @return a unmodifiable Map
>>>>> */
>>>>> - public static Map unmodifiableMap(Map map) {
>>>>> + public static <K, V> Map<K, V> unmodifiableMap(Map<K, V> map) {
>>>>> if (map == null)
>>>>> throw new NullPointerException();
>>>>> - return new UnmodifiableMap(map);
>>>>> + return new UnmodifiableMap<K, V>(map);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2172,10 +2178,10 @@
>>>>> * the Set
>>>>> * @return a unmodifiable Set
>>>>> */
>>>>> - public static Set unmodifiableSet(Set set) {
>>>>> + public static <E> Set<E> unmodifiableSet(Set<E> set) {
>>>>> if (set == null)
>>>>> throw new NullPointerException();
>>>>> - return new UnmodifiableSet(set);
>>>>> + return new UnmodifiableSet<E>(set);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2187,10 +2193,10 @@
>>>>> * the SortedMap
>>>>> * @return a unmodifiable SortedMap
>>>>> */
>>>>> - public static SortedMap unmodifiableSortedMap(SortedMap map) {
>>>>> + public static <K, V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K,
>>>>> V> map) {
>>>>> if (map == null)
>>>>> throw new NullPointerException();
>>>>> - return new UnmodifiableSortedMap(map);
>>>>> + return new UnmodifiableSortedMap<K, V>(map);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2202,10 +2208,10 @@
>>>>> * the SortedSet
>>>>> * @return a unmodifiable SortedSet
>>>>> */
>>>>> - public static SortedSet unmodifiableSortedSet(SortedSet set) {
>>>>> + public static <E> SortedSet<E> unmodifiableSortedSet(SortedSet<E> set)
>>>>> {
>>>>> if (set == null)
>>>>> throw new NullPointerException();
>>>>> - return new UnmodifiableSortedSet(set);
>>>>> + return new UnmodifiableSortedSet<E>(set);
>>>>> }
>>>>>
>>>>> /**
>>>>> @@ -2224,7 +2230,7 @@
>>>>> *
>>>>> * @since 1.5
>>>>> */
>>>>> - public static int frequency(Collection c, Object o) {
>>>>> + public static int frequency(Collection<?> c, Object o) {
>>>>> if (c == null)
>>>>> throw new NullPointerException();
>>>>> if (c.isEmpty())
>>>>> @@ -2277,7 +2283,7 @@
>>>>> *
>>>>> * @return a typesafe collection
>>>>> */
>>>>> - public static Collection checkedCollection(Collection c, Class type)
>>>>> {
>>>>> + public static <E> Collection<E> checkedCollection(Collection<E> c,
>>>>> Class
>>>>> <E> type) {
>>>>> return new CheckedCollection(c, type);
>>>>> }
>>>>>
>>>>> @@ -2289,7 +2295,7 @@
>>>>> *
>>>>> * @return a typesafe map
>>>>> */
>>>>> - public static Map checkedMap(Map m, Class keyType, Class valueType) {
>>>>> + public static <K, V> Map<K,V> checkedMap(Map<K,V> m, Class<K>
>>>>> keyType, C
>>>>> lass<V> valueType) {
>>>>> return new CheckedMap(m, keyType, valueType);
>>>>> }
>>>>>
>>>>> @@ -2301,7 +2307,7 @@
>>>>> *
>>>>> * @return a typesafe list
>>>>> */
>>>>> - public static List checkedList(List list, Class type) {
>>>>> + public static <E> List<E> checkedList(List<E> list, Class<E> type) {
>>>>> if (list instanceof RandomAccess) {
>>>>> return new CheckedRandomAccessList(list, type);
>>>>> } else {
>>>>> @@ -2317,7 +2323,7 @@
>>>>> *
>>>>> * @return a typesafe set
>>>>> */
>>>>> - public static Set checkedSet(Set s, Class type) {
>>>>> + public static <E> Set<E> checkedSet(Set<E> s, Class<E> type) {
>>>>> return new CheckedSet(s, type);
>>>>> }
>>>>>
>>>>> @@ -2329,8 +2335,8 @@
>>>>> *
>>>>> * @return a typesafe sorted map
>>>>> */
>>>>> - public static SortedMap checkedSortedMap(SortedMap m, Class keyType,
>>>>> - Class valueType) {
>>>>> + public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V>
>>>>> m, Cl
>>>>> ass<K> keyType,
>>>>> + Class<V> valueType) {
>>>>> return new CheckedSortedMap(m, keyType, valueType);
>>>>> }
>>>>>
>>>>> @@ -2342,7 +2348,7 @@
>>>>> *
>>>>> * @return a typesafe sorted set
>>>>> */
>>>>> - public static SortedSet checkedSortedSet(SortedSet s, Class type) {
>>>>> + public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,
>>>>> Class<E>
>>>>> type) {
>>>>> return new CheckedSortedSet(s, type);
>>>>> }
>>>>>
>>>>> @@ -2377,7 +2383,7 @@
>>>>> *
>>>>> * @exception NullPointerException if one of the collections is null
>>>>> */
>>>>> - public static boolean disjoint(Collection c1, Collection c2) {
>>>>> + public static boolean disjoint(Collection<?> c1, Collection<?> c2) {
>>>>> if ((c1 instanceof Set) && !(c2 instanceof Set)
>>>>> || (c2.size()) > c1.size()) {
>>>>> Collection tmp = c1;
>>>>>
>>>> ---------------------------------------------------------------------
>>>> Terms of use : http://incubator.apache.org/harmony/mailing.html
>>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>>
>>>>
>>> ---------------------------------------------------------------------
>>> Terms of use : http://incubator.apache.org/harmony/mailing.html
>>> To unsubscribe, e-mail: [EMAIL PROTECTED]
>>> For additional commands, e-mail: [EMAIL PROTECTED]
>>>
>>>
>
> ---------------------------------------------------------------------
> Terms of use : http://incubator.apache.org/harmony/mailing.html
> To unsubscribe, e-mail: [EMAIL PROTECTED]
> For additional commands, e-mail: [EMAIL PROTECTED]
>
>
--
Tim Ellison ([EMAIL PROTECTED])
IBM Java technology centre, UK.
---------------------------------------------------------------------
Terms of use : http://incubator.apache.org/harmony/mailing.html
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
