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] > > -- 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]