harmony-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Geir Magnusson Jr <g...@pobox.com>
Subject Re: [classlib] build failure
Date Fri, 09 Jun 2006 09:32:09 GMT
I'll try it.  I guess I have to rollback the rollback. :/

geir

Tim Ellison wrote:
> 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, ndbeyer@apache.org 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: harmony-dev-unsubscribe@incubator.apache.org
>>>>> For additional commands, e-mail: harmony-dev-help@incubator.apache.org
>>>>>
>>>>>
>>>> ---------------------------------------------------------------------
>>>> Terms of use : http://incubator.apache.org/harmony/mailing.html
>>>> To unsubscribe, e-mail: harmony-dev-unsubscribe@incubator.apache.org
>>>> For additional commands, e-mail: harmony-dev-help@incubator.apache.org
>>>>
>>>>
>> ---------------------------------------------------------------------
>> Terms of use : http://incubator.apache.org/harmony/mailing.html
>> To unsubscribe, e-mail: harmony-dev-unsubscribe@incubator.apache.org
>> For additional commands, e-mail: harmony-dev-help@incubator.apache.org
>>
>>
> 

---------------------------------------------------------------------
Terms of use : http://incubator.apache.org/harmony/mailing.html
To unsubscribe, e-mail: harmony-dev-unsubscribe@incubator.apache.org
For additional commands, e-mail: harmony-dev-help@incubator.apache.org


Mime
View raw message