ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/main/java/util/Vector.java

Comparing jsr166/src/main/java/util/Vector.java (file contents):
Revision 1.15 by jsr166, Sun Jun 25 19:58:14 2006 UTC vs.
Revision 1.26 by jsr166, Wed Jul 22 00:00:07 2009 UTC

#	Line 1 | Line 1
1		/*
2	<	* %W% %E%
2	>	* Copyright 1994-2008 Sun Microsystems, Inc.  All Rights Reserved.
3	>	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4		*
5	<	* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
6	<	* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
5	>	* This code is free software; you can redistribute it and/or modify it
6	>	* under the terms of the GNU General Public License version 2 only, as
7	>	* published by the Free Software Foundation.  Sun designates this
8	>	* particular file as subject to the "Classpath" exception as provided
9	>	* by Sun in the LICENSE file that accompanied this code.
10	>	*
11	>	* This code is distributed in the hope that it will be useful, but WITHOUT
12	>	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13	>	* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14	>	* version 2 for more details (a copy is included in the LICENSE file that
15	>	* accompanied this code).
16	>	*
17	>	* You should have received a copy of the GNU General Public License version
18	>	* 2 along with this work; if not, write to the Free Software Foundation,
19	>	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20	>	*
21	>	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22	>	* CA 95054 USA or visit www.sun.com if you need additional information or
23	>	* have any questions.
24		*/
25
26		package java.util;
#	Line 23 | Line 41 | package java.util;
41		* capacity of a vector before inserting a large number of
42		* components; this reduces the amount of incremental reallocation.
43		*
44	<	* <p>The Iterators returned by Vector's iterator and listIterator
45	<	* methods are <em>fail-fast</em>: if the Vector is structurally modified
46	<	* at any time after the Iterator is created, in any way except through the
47	<	* Iterator's own remove or add methods, the Iterator will throw a
48	<	* ConcurrentModificationException.  Thus, in the face of concurrent
49	<	* modification, the Iterator fails quickly and cleanly, rather than risking
50	<	* arbitrary, non-deterministic behavior at an undetermined time in the future.
51	<	* The Enumerations returned by Vector's elements method are <em>not</em>
52	<	* fail-fast.
44	>	* <p><a name="fail-fast"/>
45	>	* The iterators returned by this class's {@link #iterator() iterator} and
46	>	* {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>:
47	>	* if the vector is structurally modified at any time after the iterator is
48	>	* created, in any way except through the iterator's own
49	>	* {@link ListIterator#remove() remove} or
50	>	* {@link ListIterator#add(Object) add} methods, the iterator will throw a
51	>	* {@link ConcurrentModificationException}.  Thus, in the face of
52	>	* concurrent modification, the iterator fails quickly and cleanly, rather
53	>	* than risking arbitrary, non-deterministic behavior at an undetermined
54	>	* time in the future.  The {@link Enumeration Enumerations} returned by
55	>	* the {@link #elements() elements} method are <em>not</em> fail-fast.
56		*
57		* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
58		* as it is, generally speaking, impossible to make any hard guarantees in the
#	Line 43 | Line 64 | package java.util;
64		*
65		* <p>As of the Java 2 platform v1.2, this class was retrofitted to
66		* implement the {@link List} interface, making it a member of the
67	<	* <a href="{@docRoot}/../technotes/guides/collections/index.html"> Java
68	<	* Collections Framework</a>.  Unlike the new collection
69	<	* implementations, {@code Vector} is synchronized.
67	>	* <a href="{@docRoot}/../technotes/guides/collections/index.html">
68	>	* Java Collections Framework</a>.  Unlike the new collection
69	>	* implementations, {@code Vector} is synchronized.  If a thread-safe
70	>	* implementation is not needed, it is recommended to use {@link
71	>	* ArrayList} in place of {@code Vector}.
72		*
73		* @author  Lee Boynton
74		* @author  Jonathan Payne
52	–	* @version %I%, %G%
75		* @see Collection
54	–	* @see List
55	–	* @see ArrayList
76		* @see LinkedList
77		* @since   JDK1.0
78		*/
#	Line 104 | Line 124 | public class Vector<E>
124		*         is negative
125		*/
126		public Vector(int initialCapacity, int capacityIncrement) {
127	<	super();
127	>	super();
128		if (initialCapacity < 0)
129		throw new IllegalArgumentException("Illegal Capacity: "+
130		initialCapacity);
131	<	this.elementData = new Object[initialCapacity];
132	<	this.capacityIncrement = capacityIncrement;
131	>	this.elementData = new Object[initialCapacity];
132	>	this.capacityIncrement = capacityIncrement;
133		}
134
135		/**
#	Line 121 | Line 141 | public class Vector<E>
141		*         is negative
142		*/
143		public Vector(int initialCapacity) {
144	<	this(initialCapacity, 0);
144	>	this(initialCapacity, 0);
145		}
146
147		/**
#	Line 130 | Line 150 | public class Vector<E>
150		* zero.
151		*/
152		public Vector() {
153	<	this(10);
153	>	this(10);
154		}
155
156		/**
#	Line 144 | Line 164 | public class Vector<E>
164		* @since   1.2
165		*/
166		public Vector(Collection<? extends E> c) {
167	<	elementData = c.toArray();
168	<	elementCount = elementData.length;
169	<	// c.toArray might (incorrectly) not return Object[] (see 6260652)
170	<	if (elementData.getClass() != Object[].class)
171	<	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
167	>	elementData = c.toArray();
168	>	elementCount = elementData.length;
169	>	// c.toArray might (incorrectly) not return Object[] (see 6260652)
170	>	if (elementData.getClass() != Object[].class)
171	>	elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
172		}
173
174		/**
#	Line 165 | Line 185 | public class Vector<E>
185		* @see #toArray(Object[])
186		*/
187		public synchronized void copyInto(Object[] anArray) {
188	<	System.arraycopy(elementData, 0, anArray, 0, elementCount);
188	>	System.arraycopy(elementData, 0, anArray, 0, elementCount);
189		}
190
191		/**
#	Line 177 | Line 197 | public class Vector<E>
197		* minimize the storage of a vector.
198		*/
199		public synchronized void trimToSize() {
200	<	modCount++;
201	<	int oldCapacity = elementData.length;
202	<	if (elementCount < oldCapacity) {
200	>	modCount++;
201	>	int oldCapacity = elementData.length;
202	>	if (elementCount < oldCapacity) {
203		elementData = Arrays.copyOf(elementData, elementCount);
204	<	}
204	>	}
205		}
206
207		/**
#	Line 202 | Line 222 | public class Vector<E>
222		* @param minCapacity the desired minimum capacity
223		*/
224		public synchronized void ensureCapacity(int minCapacity) {
225	<	modCount++;
226	<	ensureCapacityHelper(minCapacity);
225	>	modCount++;
226	>	ensureCapacityHelper(minCapacity);
227		}
228
229		/**
#	Line 215 | Line 235 | public class Vector<E>
235		* @see #ensureCapacity(int)
236		*/
237		private void ensureCapacityHelper(int minCapacity) {
238	<	int oldCapacity = elementData.length;
239	<	if (minCapacity > oldCapacity) {
240	<	Object[] oldData = elementData;
241	<	int newCapacity = (capacityIncrement > 0) ?
242	<	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
243	<	if (newCapacity < minCapacity) {
244	<	newCapacity = minCapacity;
245	<	}
238	>	int oldCapacity = elementData.length;
239	>	if (minCapacity > oldCapacity) {
240	>	Object[] oldData = elementData;
241	>	int newCapacity = (capacityIncrement > 0) ?
242	>	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
243	>	if (newCapacity < minCapacity) {
244	>	newCapacity = minCapacity;
245	>	}
246		elementData = Arrays.copyOf(elementData, newCapacity);
247	<	}
247	>	}
248		}
249
250		/**
#	Line 233 | Line 253 | public class Vector<E>
253		* the vector. If the new size is less than the current size, all
254		* components at index {@code newSize} and greater are discarded.
255		*
256	<	* @param   newSize   the new size of this vector
257	<	* @throws  ArrayIndexOutOfBoundsException if new size is negative
256	>	* @param  newSize   the new size of this vector
257	>	* @throws ArrayIndexOutOfBoundsException if the new size is negative
258		*/
259		public synchronized void setSize(int newSize) {
260	<	modCount++;
261	<	if (newSize > elementCount) {
262	<	ensureCapacityHelper(newSize);
263	<	} else {
264	<	for (int i = newSize ; i < elementCount ; i++) {
265	<	elementData[i] = null;
266	<	}
267	<	}
268	<	elementCount = newSize;
260	>	modCount++;
261	>	if (newSize > elementCount) {
262	>	ensureCapacityHelper(newSize);
263	>	} else {
264	>	for (int i = newSize ; i < elementCount ; i++) {
265	>	elementData[i] = null;
266	>	}
267	>	}
268	>	elementCount = newSize;
269		}
270
271		/**
#	Line 256 | Line 276 | public class Vector<E>
276		*          of this vector)
277		*/
278		public synchronized int capacity() {
279	<	return elementData.length;
279	>	return elementData.length;
280		}
281
282		/**
#	Line 265 | Line 285 | public class Vector<E>
285		* @return  the number of components in this vector
286		*/
287		public synchronized int size() {
288	<	return elementCount;
288	>	return elementCount;
289		}
290
291		/**
#	Line 276 | Line 296 | public class Vector<E>
296		*          {@code false} otherwise.
297		*/
298		public synchronized boolean isEmpty() {
299	<	return elementCount == 0;
299	>	return elementCount == 0;
300		}
301
302		/**
#	Line 289 | Line 309 | public class Vector<E>
309		* @see     Iterator
310		*/
311		public Enumeration<E> elements() {
312	<	return new Enumeration<E>() {
313	<	int count = 0;
312	>	return new Enumeration<E>() {
313	>	int count = 0;
314	>
315	>	public boolean hasMoreElements() {
316	>	return count < elementCount;
317	>	}
318
319	<	public boolean hasMoreElements() {
320	<	return count < elementCount;
321	<	}
322	<
323	<	public E nextElement() {
324	<	synchronized (Vector.this) {
325	<	if (count < elementCount) {
326	<	return (E)elementData[count++];
327	<	}
304	<	}
305	<	throw new NoSuchElementException("Vector Enumeration");
306	<	}
307	<	};
319	>	public E nextElement() {
320	>	synchronized (Vector.this) {
321	>	if (count < elementCount) {
322	>	return elementData(count++);
323	>	}
324	>	}
325	>	throw new NoSuchElementException("Vector Enumeration");
326	>	}
327	>	};
328		}
329
330		/**
#	Line 317 | Line 337 | public class Vector<E>
337		* @return {@code true} if this vector contains the specified element
338		*/
339		public boolean contains(Object o) {
340	<	return indexOf(o, 0) >= 0;
340	>	return indexOf(o, 0) >= 0;
341		}
342
343		/**
#	Line 332 | Line 352 | public class Vector<E>
352		*         this vector, or -1 if this vector does not contain the element
353		*/
354		public int indexOf(Object o) {
355	<	return indexOf(o, 0);
355	>	return indexOf(o, 0);
356		}
357
358		/**
#	Line 352 | Line 372 | public class Vector<E>
372		* @see     Object#equals(Object)
373		*/
374		public synchronized int indexOf(Object o, int index) {
375	<	if (o == null) {
376	<	for (int i = index ; i < elementCount ; i++)
377	<	if (elementData[i]==null)
378	<	return i;
379	<	} else {
380	<	for (int i = index ; i < elementCount ; i++)
381	<	if (o.equals(elementData[i]))
382	<	return i;
383	<	}
384	<	return -1;
375	>	if (o == null) {
376	>	for (int i = index ; i < elementCount ; i++)
377	>	if (elementData[i]==null)
378	>	return i;
379	>	} else {
380	>	for (int i = index ; i < elementCount ; i++)
381	>	if (o.equals(elementData[i]))
382	>	return i;
383	>	}
384	>	return -1;
385		}
386
387		/**
#	Line 376 | Line 396 | public class Vector<E>
396		*         this vector, or -1 if this vector does not contain the element
397		*/
398		public synchronized int lastIndexOf(Object o) {
399	<	return lastIndexOf(o, elementCount-1);
399	>	return lastIndexOf(o, elementCount-1);
400		}
401
402		/**
#	Line 399 | Line 419 | public class Vector<E>
419		if (index >= elementCount)
420		throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
421
422	<	if (o == null) {
423	<	for (int i = index; i >= 0; i--)
424	<	if (elementData[i]==null)
425	<	return i;
426	<	} else {
427	<	for (int i = index; i >= 0; i--)
428	<	if (o.equals(elementData[i]))
429	<	return i;
430	<	}
431	<	return -1;
422	>	if (o == null) {
423	>	for (int i = index; i >= 0; i--)
424	>	if (elementData[i]==null)
425	>	return i;
426	>	} else {
427	>	for (int i = index; i >= 0; i--)
428	>	if (o.equals(elementData[i]))
429	>	return i;
430	>	}
431	>	return -1;
432		}
433
434		/**
#	Line 420 | Line 440 | public class Vector<E>
440		* @param      index   an index into this vector
441		* @return     the component at the specified index
442		* @throws ArrayIndexOutOfBoundsException if the index is out of range
443	<	*         ({@code index < 0 || index >= size()})
443	>	*         ({@code index < 0 || index >= size()})
444		*/
445		public synchronized E elementAt(int index) {
446	<	if (index >= elementCount) {
447	<	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
448	<	}
446	>	if (index >= elementCount) {
447	>	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
448	>	}
449
450	<	return (E)elementData[index];
450	>	return elementData(index);
451		}
452
453		/**
#	Line 438 | Line 458 | public class Vector<E>
458		* @throws NoSuchElementException if this vector has no components
459		*/
460		public synchronized E firstElement() {
461	<	if (elementCount == 0) {
462	<	throw new NoSuchElementException();
463	<	}
464	<	return (E)elementData[0];
461	>	if (elementCount == 0) {
462	>	throw new NoSuchElementException();
463	>	}
464	>	return elementData(0);
465		}
466
467		/**
#	Line 452 | Line 472 | public class Vector<E>
472		* @throws NoSuchElementException if this vector is empty
473		*/
474		public synchronized E lastElement() {
475	<	if (elementCount == 0) {
476	<	throw new NoSuchElementException();
477	<	}
478	<	return (E)elementData[elementCount - 1];
475	>	if (elementCount == 0) {
476	>	throw new NoSuchElementException();
477	>	}
478	>	return elementData(elementCount - 1);
479		}
480
481		/**
482		* Sets the component at the specified {@code index} of this
483		* vector to be the specified object. The previous component at that
484	<	* position is discarded.<p>
484	>	* position is discarded.
485		*
486	<	* The index must be a value greater than or equal to {@code 0}
487	<	* and less than the current size of the vector. <p>
486	>	* <p>The index must be a value greater than or equal to {@code 0}
487	>	* and less than the current size of the vector.
488		*
489	<	* This method is identical in functionality to the set method
490	<	* (which is part of the List interface). Note that the set method reverses
491	<	* the order of the parameters, to more closely match array usage.  Note
492	<	* also that the set method returns the old value that was stored at the
493	<	* specified position.
489	>	* <p>This method is identical in functionality to the
490	>	* {@link #set(int, Object) set(int, E)}
491	>	* method (which is part of the {@link List} interface). Note that the
492	>	* {@code set} method reverses the order of the parameters, to more closely
493	>	* match array usage.  Note also that the {@code set} method returns the
494	>	* old value that was stored at the specified position.
495		*
496		* @param      obj     what the component is to be set to
497		* @param      index   the specified index
498	<	* @throws  ArrayIndexOutOfBoundsException  if the index was invalid
499	<	* @see        #size()
479	<	* @see        List
480	<	* @see        #set(int, java.lang.Object)
498	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
499	>	*         ({@code index < 0 || index >= size()})
500		*/
501		public synchronized void setElementAt(E obj, int index) {
502	<	if (index >= elementCount) {
503	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
504	<	elementCount);
505	<	}
506	<	elementData[index] = obj;
502	>	if (index >= elementCount) {
503	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
504	>	elementCount);
505	>	}
506	>	elementData[index] = obj;
507		}
508
509		/**
#	Line 497 | Line 516 | public class Vector<E>
516		* <p>The index must be a value greater than or equal to {@code 0}
517		* and less than the current size of the vector.
518		*
519	<	* <p>This method is identical in functionality to the remove method
520	<	* (which is part of the List interface).  Note that the remove method
521	<	* returns the old value that was stored at the specified position.
519	>	* <p>This method is identical in functionality to the {@link #remove(int)}
520	>	* method (which is part of the {@link List} interface).  Note that the
521	>	* {@code remove} method returns the old value that was stored at the
522	>	* specified position.
523		*
524		* @param      index   the index of the object to remove
525	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
526	<	* @see        #size()
507	<	* @see        #remove(int)
508	<	* @see        List
525	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
526	>	*         ({@code index < 0 || index >= size()})
527		*/
528		public synchronized void removeElementAt(int index) {
529	<	modCount++;
530	<	if (index >= elementCount) {
531	<	throw new ArrayIndexOutOfBoundsException(index + " >= " +
532	<	elementCount);
533	<	}
534	<	else if (index < 0) {
535	<	throw new ArrayIndexOutOfBoundsException(index);
536	<	}
537	<	int j = elementCount - index - 1;
538	<	if (j > 0) {
539	<	System.arraycopy(elementData, index + 1, elementData, index, j);
540	<	}
541	<	elementCount--;
542	<	elementData[elementCount] = null; /* to let gc do its work */
529	>	modCount++;
530	>	if (index >= elementCount) {
531	>	throw new ArrayIndexOutOfBoundsException(index + " >= " +
532	>	elementCount);
533	>	}
534	>	else if (index < 0) {
535	>	throw new ArrayIndexOutOfBoundsException(index);
536	>	}
537	>	int j = elementCount - index - 1;
538	>	if (j > 0) {
539	>	System.arraycopy(elementData, index + 1, elementData, index, j);
540	>	}
541	>	elementCount--;
542	>	elementData[elementCount] = null; /* to let gc do its work */
543		}
544
545		/**
#	Line 536 | Line 554 | public class Vector<E>
554		* index is equal to the current size of the vector, the new element
555		* is appended to the Vector.)
556		*
557	<	* <p>This method is identical in functionality to the add(Object, int) method
558	<	* (which is part of the List interface). Note that the add method reverses
559	<	* the order of the parameters, to more closely match array usage.
557	>	* <p>This method is identical in functionality to the
558	>	* {@link #add(int, Object) add(int, E)}
559	>	* method (which is part of the {@link List} interface).  Note that the
560	>	* {@code add} method reverses the order of the parameters, to more closely
561	>	* match array usage.
562		*
563		* @param      obj     the component to insert
564		* @param      index   where to insert the new component
565	<	* @exception  ArrayIndexOutOfBoundsException  if the index was invalid
566	<	* @see        #size()
547	<	* @see        #add(int, Object)
548	<	* @see        List
565	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
566	>	*         ({@code index < 0 || index > size()})
567		*/
568		public synchronized void insertElementAt(E obj, int index) {
569	<	modCount++;
570	<	if (index > elementCount) {
571	<	throw new ArrayIndexOutOfBoundsException(index
572	<	+ " > " + elementCount);
573	<	}
574	<	ensureCapacityHelper(elementCount + 1);
575	<	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
576	<	elementData[index] = obj;
577	<	elementCount++;
569	>	modCount++;
570	>	if (index > elementCount) {
571	>	throw new ArrayIndexOutOfBoundsException(index
572	>	+ " > " + elementCount);
573	>	}
574	>	ensureCapacityHelper(elementCount + 1);
575	>	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
576	>	elementData[index] = obj;
577	>	elementCount++;
578		}
579
580		/**
581		* Adds the specified component to the end of this vector,
582		* increasing its size by one. The capacity of this vector is
583	<	* increased if its size becomes greater than its capacity. <p>
583	>	* increased if its size becomes greater than its capacity.
584		*
585	<	* This method is identical in functionality to the add(Object) method
586	<	* (which is part of the List interface).
585	>	* <p>This method is identical in functionality to the
586	>	* {@link #add(Object) add(E)}
587	>	* method (which is part of the {@link List} interface).
588		*
589		* @param   obj   the component to be added
571	–	* @see        #add(Object)
572	–	* @see        List
590		*/
591		public synchronized void addElement(E obj) {
592	<	modCount++;
593	<	ensureCapacityHelper(elementCount + 1);
594	<	elementData[elementCount++] = obj;
592	>	modCount++;
593	>	ensureCapacityHelper(elementCount + 1);
594	>	elementData[elementCount++] = obj;
595		}
596
597		/**
#	Line 582 | Line 599 | public class Vector<E>
599		* from this vector. If the object is found in this vector, each
600		* component in the vector with an index greater or equal to the
601		* object's index is shifted downward to have an index one smaller
602	<	* than the value it had previously.<p>
602	>	* than the value it had previously.
603		*
604	<	* This method is identical in functionality to the remove(Object)
605	<	* method (which is part of the List interface).
604	>	* <p>This method is identical in functionality to the
605	>	* {@link #remove(Object)} method (which is part of the
606	>	* {@link List} interface).
607		*
608		* @param   obj   the component to be removed
609		* @return  {@code true} if the argument was a component of this
610		*          vector; {@code false} otherwise.
593	–	* @see     List#remove(Object)
594	–	* @see     List
611		*/
612		public synchronized boolean removeElement(Object obj) {
613	<	modCount++;
614	<	int i = indexOf(obj);
615	<	if (i >= 0) {
616	<	removeElementAt(i);
617	<	return true;
618	<	}
619	<	return false;
613	>	modCount++;
614	>	int i = indexOf(obj);
615	>	if (i >= 0) {
616	>	removeElementAt(i);
617	>	return true;
618	>	}
619	>	return false;
620		}
621
622		/**
623	<	* Removes all components from this vector and sets its size to zero.<p>
623	>	* Removes all components from this vector and sets its size to zero.
624		*
625	<	* This method is identical in functionality to the clear method
626	<	* (which is part of the List interface).
611	<	*
612	<	* @see     #clear
613	<	* @see     List
625	>	* <p>This method is identical in functionality to the {@link #clear}
626	>	* method (which is part of the {@link List} interface).
627		*/
628		public synchronized void removeAllElements() {
629		modCount++;
630	<	// Let gc do its work
631	<	for (int i = 0; i < elementCount; i++)
632	<	elementData[i] = null;
630	>	// Let gc do its work
631	>	for (int i = 0; i < elementCount; i++)
632	>	elementData[i] = null;
633
634	<	elementCount = 0;
634	>	elementCount = 0;
635		}
636
637		/**
#	Line 629 | Line 642 | public class Vector<E>
642		* @return  a clone of this vector
643		*/
644		public synchronized Object clone() {
645	<	try {
646	<	Vector<E> v = (Vector<E>) super.clone();
647	<	v.elementData = Arrays.copyOf(elementData, elementCount);
648	<	v.modCount = 0;
649	<	return v;
650	<	} catch (CloneNotSupportedException e) {
651	<	// this shouldn't happen, since we are Cloneable
652	<	throw new InternalError();
653	<	}
645	>	try {
646	>	@SuppressWarnings("unchecked")
647	>	Vector<E> v = (Vector<E>) super.clone();
648	>	v.elementData = Arrays.copyOf(elementData, elementCount);
649	>	v.modCount = 0;
650	>	return v;
651	>	} catch (CloneNotSupportedException e) {
652	>	// this shouldn't happen, since we are Cloneable
653	>	throw new InternalError();
654	>	}
655		}
656
657		/**
#	Line 655 | Line 669 | public class Vector<E>
669		* correct order; the runtime type of the returned array is that of the
670		* specified array.  If the Vector fits in the specified array, it is
671		* returned therein.  Otherwise, a new array is allocated with the runtime
672	<	* type of the specified array and the size of this Vector.<p>
672	>	* type of the specified array and the size of this Vector.
673		*
674	<	* If the Vector fits in the specified array with room to spare
674	>	* <p>If the Vector fits in the specified array with room to spare
675		* (i.e., the array has more elements than the Vector),
676		* the element in the array immediately following the end of the
677		* Vector is set to null.  (This is useful in determining the length
#	Line 665 | Line 679 | public class Vector<E>
679		* does not contain any null elements.)
680		*
681		* @param a the array into which the elements of the Vector are to
682	<	*          be stored, if it is big enough; otherwise, a new array of the
683	<	*          same runtime type is allocated for this purpose.
682	>	*          be stored, if it is big enough; otherwise, a new array of the
683	>	*          same runtime type is allocated for this purpose.
684		* @return an array containing the elements of the Vector
685	<	* @exception ArrayStoreException the runtime type of a is not a supertype
685	>	* @throws ArrayStoreException if the runtime type of a is not a supertype
686		* of the runtime type of every element in this Vector
687		* @throws NullPointerException if the given array is null
688		* @since 1.2
689		*/
690	+	@SuppressWarnings("unchecked")
691		public synchronized <T> T[] toArray(T[] a) {
692		if (a.length < elementCount)
693		return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
694
695	<	System.arraycopy(elementData, 0, a, 0, elementCount);
695	>	System.arraycopy(elementData, 0, a, 0, elementCount);
696
697		if (a.length > elementCount)
698		a[elementCount] = null;
#	Line 687 | Line 702 | public class Vector<E>
702
703		// Positional Access Operations
704
705	+	@SuppressWarnings("unchecked")
706	+	E elementData(int index) {
707	+	return (E) elementData[index];
708	+	}
709	+
710		/**
711		* Returns the element at the specified position in this Vector.
712		*
713		* @param index index of the element to return
714		* @return object at the specified index
715	<	* @exception ArrayIndexOutOfBoundsException index is out of range (index
716	<	*            &lt; 0 || index &gt;= size())
715	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
716	>	*            ({@code index < 0 || index >= size()})
717		* @since 1.2
718		*/
719		public synchronized E get(int index) {
720	<	if (index >= elementCount)
721	<	throw new ArrayIndexOutOfBoundsException(index);
720	>	if (index >= elementCount)
721	>	throw new ArrayIndexOutOfBoundsException(index);
722
723	<	return (E)elementData[index];
723	>	return elementData(index);
724		}
725
726		/**
#	Line 710 | Line 730 | public class Vector<E>
730		* @param index index of the element to replace
731		* @param element element to be stored at the specified position
732		* @return the element previously at the specified position
733	<	* @exception ArrayIndexOutOfBoundsException index out of range
734	<	*            (index &lt; 0 || index &gt;= size())
733	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
734	>	*         ({@code index < 0 || index >= size()})
735		* @since 1.2
736		*/
737		public synchronized E set(int index, E element) {
738	<	if (index >= elementCount)
739	<	throw new ArrayIndexOutOfBoundsException(index);
738	>	if (index >= elementCount)
739	>	throw new ArrayIndexOutOfBoundsException(index);
740
741	<	Object oldValue = elementData[index];
742	<	elementData[index] = element;
743	<	return (E)oldValue;
741	>	E oldValue = elementData(index);
742	>	elementData[index] = element;
743	>	return oldValue;
744		}
745
746		/**
#	Line 731 | Line 751 | public class Vector<E>
751		* @since 1.2
752		*/
753		public synchronized boolean add(E e) {
754	<	modCount++;
755	<	ensureCapacityHelper(elementCount + 1);
756	<	elementData[elementCount++] = e;
754	>	modCount++;
755	>	ensureCapacityHelper(elementCount + 1);
756	>	elementData[elementCount++] = e;
757		return true;
758		}
759
#	Line 759 | Line 779 | public class Vector<E>
779		*
780		* @param index index at which the specified element is to be inserted
781		* @param element element to be inserted
782	<	* @exception ArrayIndexOutOfBoundsException index is out of range
783	<	*            (index &lt; 0 || index &gt; size())
782	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
783	>	*         ({@code index < 0 || index > size()})
784		* @since 1.2
785		*/
786		public void add(int index, E element) {
#	Line 772 | Line 792 | public class Vector<E>
792		* Shifts any subsequent elements to the left (subtracts one from their
793		* indices).  Returns the element that was removed from the Vector.
794		*
795	<	* @exception ArrayIndexOutOfBoundsException index out of range (index
796	<	*            &lt; 0 || index &gt;= size())
795	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
796	>	*         ({@code index < 0 || index >= size()})
797		* @param index the index of the element to be removed
798		* @return element that was removed
799		* @since 1.2
800		*/
801		public synchronized E remove(int index) {
802	<	modCount++;
803	<	if (index >= elementCount)
804	<	throw new ArrayIndexOutOfBoundsException(index);
805	<	Object oldValue = elementData[index];
806	<
807	<	int numMoved = elementCount - index - 1;
808	<	if (numMoved > 0)
809	<	System.arraycopy(elementData, index+1, elementData, index,
810	<	numMoved);
811	<	elementData[--elementCount] = null; // Let gc do its work
802	>	modCount++;
803	>	if (index >= elementCount)
804	>	throw new ArrayIndexOutOfBoundsException(index);
805	>	E oldValue = elementData(index);
806	>
807	>	int numMoved = elementCount - index - 1;
808	>	if (numMoved > 0)
809	>	System.arraycopy(elementData, index+1, elementData, index,
810	>	numMoved);
811	>	elementData[--elementCount] = null; // Let gc do its work
812
813	<	return (E)oldValue;
813	>	return oldValue;
814		}
815
816		/**
#	Line 812 | Line 832 | public class Vector<E>
832		* @param   c a collection whose elements will be tested for containment
833		*          in this Vector
834		* @return true if this Vector contains all of the elements in the
835	<	*         specified collection
835	>	*         specified collection
836		* @throws NullPointerException if the specified collection is null
837		*/
838		public synchronized boolean containsAll(Collection<?> c) {
#	Line 833 | Line 853 | public class Vector<E>
853		* @since 1.2
854		*/
855		public synchronized boolean addAll(Collection<? extends E> c) {
856	<	modCount++;
856	>	modCount++;
857		Object[] a = c.toArray();
858		int numNew = a.length;
859	<	ensureCapacityHelper(elementCount + numNew);
859	>	ensureCapacityHelper(elementCount + numNew);
860		System.arraycopy(a, 0, elementData, elementCount, numNew);
861		elementCount += numNew;
862	<	return numNew != 0;
862	>	return numNew != 0;
863		}
864
865		/**
#	Line 892 | Line 912 | public class Vector<E>
912		*              specified collection
913		* @param c elements to be inserted into this Vector
914		* @return {@code true} if this Vector changed as a result of the call
915	<	* @exception ArrayIndexOutOfBoundsException index out of range (index
916	<	*            &lt; 0 || index &gt; size())
915	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
916	>	*         ({@code index < 0 || index > size()})
917		* @throws NullPointerException if the specified collection is null
918		* @since 1.2
919		*/
920		public synchronized boolean addAll(int index, Collection<? extends E> c) {
921	<	modCount++;
922	<	if (index < 0 || index > elementCount)
923	<	throw new ArrayIndexOutOfBoundsException(index);
921	>	modCount++;
922	>	if (index < 0 || index > elementCount)
923	>	throw new ArrayIndexOutOfBoundsException(index);
924
925		Object[] a = c.toArray();
926	<	int numNew = a.length;
927	<	ensureCapacityHelper(elementCount + numNew);
926	>	int numNew = a.length;
927	>	ensureCapacityHelper(elementCount + numNew);
928
929	<	int numMoved = elementCount - index;
930	<	if (numMoved > 0)
931	<	System.arraycopy(elementData, index, elementData, index + numNew,
932	<	numMoved);
929	>	int numMoved = elementCount - index;
930	>	if (numMoved > 0)
931	>	System.arraycopy(elementData, index, elementData, index + numNew,
932	>	numMoved);
933
934		System.arraycopy(a, 0, elementData, index, numNew);
935	<	elementCount += numNew;
936	<	return numNew != 0;
935	>	elementCount += numNew;
936	>	return numNew != 0;
937		}
938
939		/**
#	Line 948 | Line 968 | public class Vector<E>
968		}
969
970		/**
971	<	* Removes from this List all of the elements whose index is between
972	<	* fromIndex, inclusive and toIndex, exclusive.  Shifts any succeeding
973	<	* elements to the left (reduces their index).
974	<	* This call shortens the Vector by (toIndex - fromIndex) elements.  (If
975	<	* toIndex==fromIndex, this operation has no effect.)
971	>	* Returns a view of the portion of this List between fromIndex,
972	>	* inclusive, and toIndex, exclusive.  (If fromIndex and toIndex are
973	>	* equal, the returned List is empty.)  The returned List is backed by this
974	>	* List, so changes in the returned List are reflected in this List, and
975	>	* vice-versa.  The returned List supports all of the optional List
976	>	* operations supported by this List.
977		*
978	<	* @param fromIndex index of first element to be removed
979	<	* @param toIndex index after last element to be removed
978	>	* <p>This method eliminates the need for explicit range operations (of
979	>	* the sort that commonly exist for arrays).  Any operation that expects
980	>	* a List can be used as a range operation by operating on a subList view
981	>	* instead of a whole List.  For example, the following idiom
982	>	* removes a range of elements from a List:
983	>	* <pre>
984	>	*      list.subList(from, to).clear();
985	>	* </pre>
986	>	* Similar idioms may be constructed for indexOf and lastIndexOf,
987	>	* and all of the algorithms in the Collections class can be applied to
988	>	* a subList.
989	>	*
990	>	* <p>The semantics of the List returned by this method become undefined if
991	>	* the backing list (i.e., this List) is <i>structurally modified</i> in
992	>	* any way other than via the returned List.  (Structural modifications are
993	>	* those that change the size of the List, or otherwise perturb it in such
994	>	* a fashion that iterations in progress may yield incorrect results.)
995	>	*
996	>	* @param fromIndex low endpoint (inclusive) of the subList
997	>	* @param toIndex high endpoint (exclusive) of the subList
998	>	* @return a view of the specified range within this List
999	>	* @throws IndexOutOfBoundsException if an endpoint index value is out of range
1000	>	*         {@code (fromIndex < 0 || toIndex > size)}
1001	>	* @throws IllegalArgumentException if the endpoint indices are out of order
1002	>	*         {@code (fromIndex > toIndex)}
1003	>	*/
1004	>	public synchronized List<E> subList(int fromIndex, int toIndex) {
1005	>	return Collections.synchronizedList(super.subList(fromIndex, toIndex),
1006	>	this);
1007	>	}
1008	>
1009	>	/**
1010	>	* Removes from this list all of the elements whose index is between
1011	>	* {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.
1012	>	* Shifts any succeeding elements to the left (reduces their index).
1013	>	* This call shortens the list by {@code (toIndex - fromIndex)} elements.
1014	>	* (If {@code toIndex==fromIndex}, this operation has no effect.)
1015		*/
1016		protected synchronized void removeRange(int fromIndex, int toIndex) {
1017	<	modCount++;
1018	<	int numMoved = elementCount - toIndex;
1017	>	modCount++;
1018	>	int numMoved = elementCount - toIndex;
1019		System.arraycopy(elementData, toIndex, elementData, fromIndex,
1020		numMoved);
1021
1022	<	// Let gc do its work
1023	<	int newElementCount = elementCount - (toIndex-fromIndex);
1024	<	while (elementCount != newElementCount)
1025	<	elementData[--elementCount] = null;
1022	>	// Let gc do its work
1023	>	int newElementCount = elementCount - (toIndex-fromIndex);
1024	>	while (elementCount != newElementCount)
1025	>	elementData[--elementCount] = null;
1026		}
1027
1028		/**
#	Line 977 | Line 1033 | public class Vector<E>
1033		private synchronized void writeObject(java.io.ObjectOutputStream s)
1034		throws java.io.IOException
1035		{
1036	<	s.defaultWriteObject();
1036	>	s.defaultWriteObject();
1037		}
1038
1039		/**
1040	<	* Returns a list-iterator of the elements in this list (in proper
1040	>	* Returns a list iterator over the elements in this list (in proper
1041		* sequence), starting at the specified position in the list.
1042	<	* Obeys the general contract of {@link List#listIterator(int)}.
1042	>	* The specified index indicates the first element that would be
1043	>	* returned by an initial call to {@link ListIterator#next next}.
1044	>	* An initial call to {@link ListIterator#previous previous} would
1045	>	* return the element with the specified index minus one.
1046	>	*
1047	>	* <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1048		*
988	–	* <p>The list-iterator is <i>fail-fast</i>: if the list is structurally
989	–	* modified at any time after the Iterator is created, in any way except
990	–	* through the list-iterator's own {@code remove} or {@code add}
991	–	* methods, the list-iterator will throw a
992	–	* {@code ConcurrentModificationException}.  Thus, in the face of
993	–	* concurrent modification, the iterator fails quickly and cleanly, rather
994	–	* than risking arbitrary, non-deterministic behavior at an undetermined
995	–	* time in the future.
996	–	*
997	–	* @param index index of the first element to be returned from the
998	–	*        list-iterator (by a call to {@link ListIterator#next})
999	–	* @return a list-iterator of the elements in this list (in proper
1000	–	*         sequence), starting at the specified position in the list
1049		* @throws IndexOutOfBoundsException {@inheritDoc}
1050		*/
1051		public synchronized ListIterator<E> listIterator(int index) {
1052	<	if (index < 0 || index > elementCount)
1052	>	if (index < 0 || index > elementCount)
1053		throw new IndexOutOfBoundsException("Index: "+index);
1054	<	return new VectorIterator(index, elementCount);
1054	>	return new ListItr(index);
1055		}
1056
1057		/**
1058	<	* {@inheritDoc}
1058	>	* Returns a list iterator over the elements in this list (in proper
1059	>	* sequence).
1060	>	*
1061	>	* <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1062	>	*
1063	>	* @see #listIterator(int)
1064		*/
1065		public synchronized ListIterator<E> listIterator() {
1066	<	return new VectorIterator(0, elementCount);
1066	>	return new ListItr(0);
1067		}
1068
1069		/**
1070		* Returns an iterator over the elements in this list in proper sequence.
1071		*
1072	+	* <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
1073	+	*
1074		* @return an iterator over the elements in this list in proper sequence
1075		*/
1076		public synchronized Iterator<E> iterator() {
1077	<	return new VectorIterator(0, elementCount);
1077	>	return new Itr();
1078		}
1079
1080		/**
1081	<	* Helper method to access array elements under synchronization by
1027	<	* iterators. The caller performs index check with respect to
1028	<	* expected bounds, so errors accessing the element are reported
1029	<	* as ConcurrentModificationExceptions.
1081	>	* An optimized version of AbstractList.Itr
1082		*/
1083	<	final synchronized Object iteratorGet(int index, int expectedModCount) {
1084	<	if (modCount == expectedModCount) {
1085	<	try {
1086	<	return elementData[index];
1035	<	} catch(IndexOutOfBoundsException fallThrough) {
1036	<	}
1037	<	}
1038	<	throw new ConcurrentModificationException();
1039	<	}
1040	<
1041	<	/**
1042	<	* Streamlined specialization of AbstractList version of iterator.
1043	<	* Locally perfroms bounds checks, but relies on outer Vector
1044	<	* to access elements under synchronization.
1045	<	*/
1046	<	private final class VectorIterator implements ListIterator<E> {
1047	<	int cursor;              // Index of next element to return;
1048	<	int fence;               // Upper bound on cursor (cache of size())
1049	<	int lastRet;             // Index of last element, or -1 if no such
1050	<	int expectedModCount;    // To check for CME
1051	<
1052	<	VectorIterator(int index, int fence) {
1053	<	this.cursor = index;
1054	<	this.fence = fence;
1055	<	this.lastRet = -1;
1056	<	this.expectedModCount = Vector.this.modCount;
1057	<	}
1058	<
1059	<	public boolean hasNext() {
1060	<	return cursor < fence;
1061	<	}
1062	<
1063	<	public boolean hasPrevious() {
1064	<	return cursor > 0;
1065	<	}
1066	<
1067	<	public int nextIndex() {
1068	<	return cursor;
1069	<	}
1070	<
1071	<	public int previousIndex() {
1072	<	return cursor - 1;
1073	<	}
1074	<
1075	<	public E next() {
1076	<	int i = cursor;
1077	<	if (i >= fence)
1078	<	throw new NoSuchElementException();
1079	<	Object next = Vector.this.iteratorGet(i, expectedModCount);
1080	<	lastRet = i;
1081	<	cursor = i + 1;
1082	<	return (E)next;
1083	<	}
1083	>	private class Itr implements Iterator<E> {
1084	>	int cursor;       // index of next element to return
1085	>	int lastRet = -1; // index of last element returned; -1 if no such
1086	>	int expectedModCount = modCount;
1087
1088	<	public E previous() {
1089	<	int i = cursor - 1;
1090	<	if (i < 0)
1091	<	throw new NoSuchElementException();
1089	<	Object prev = Vector.this.iteratorGet(i, expectedModCount);
1090	<	lastRet = i;
1091	<	cursor = i;
1092	<	return (E)prev;
1088	>	public boolean hasNext() {
1089	>	// Racy but within spec, since modifications are checked
1090	>	// within or after synchronization in next/previous
1091	>	return cursor != elementCount;
1092		}
1093
1094	<	public void set(E e) {
1095	<	if (lastRet < 0)
1096	<	throw new IllegalStateException();
1098	<	if (Vector.this.modCount != expectedModCount)
1099	<	throw new ConcurrentModificationException();
1100	<	try {
1101	<	Vector.this.set(lastRet, e);
1102	<	expectedModCount = Vector.this.modCount;
1103	<	} catch (IndexOutOfBoundsException ex) {
1104	<	throw new ConcurrentModificationException();
1105	<	}
1106	<	}
1107	<
1108	<	public void remove() {
1109	<	int i = lastRet;
1110	<	if (i < 0)
1111	<	throw new IllegalStateException();
1112	<	if (Vector.this.modCount != expectedModCount)
1113	<	throw new ConcurrentModificationException();
1114	<	try {
1115	<	Vector.this.remove(i);
1116	<	if (i < cursor)
1117	<	cursor--;
1118	<	lastRet = -1;
1119	<	fence = Vector.this.size();
1120	<	expectedModCount = Vector.this.modCount;
1121	<	} catch (IndexOutOfBoundsException ex) {
1122	<	throw new ConcurrentModificationException();
1123	<	}
1124	<	}
1125	<
1126	<	public void add(E e) {
1127	<	if (Vector.this.modCount != expectedModCount)
1128	<	throw new ConcurrentModificationException();
1129	<	try {
1094	>	public E next() {
1095	>	synchronized (Vector.this) {
1096	>	checkForComodification();
1097		int i = cursor;
1098	<	Vector.this.add(i, e);
1098	>	if (i >= elementCount)
1099	>	throw new NoSuchElementException();
1100		cursor = i + 1;
1101	<	lastRet = -1;
1134	<	fence = Vector.this.size();
1135	<	expectedModCount = Vector.this.modCount;
1136	<	} catch (IndexOutOfBoundsException ex) {
1137	<	throw new ConcurrentModificationException();
1138	<	}
1139	<	}
1140	<	}
1141	<
1142	<	/**
1143	<	* Returns a view of the portion of this List between fromIndex,
1144	<	* inclusive, and toIndex, exclusive.  (If fromIndex and toIndex are
1145	<	* equal, the returned List is empty.)  The returned List is backed by this
1146	<	* List, so changes in the returned List are reflected in this List, and
1147	<	* vice-versa.  The returned List supports all of the optional List
1148	<	* operations supported by this List.<p>
1149	<	*
1150	<	* This method eliminates the need for explicit range operations (of
1151	<	* the sort that commonly exist for arrays).   Any operation that expects
1152	<	* a List can be used as a range operation by operating on a subList view
1153	<	* instead of a whole List.  For example, the following idiom
1154	<	* removes a range of elements from a List:
1155	<	* <pre>
1156	<	*      list.subList(from, to).clear();
1157	<	* </pre>
1158	<	* Similar idioms may be constructed for indexOf and lastIndexOf,
1159	<	* and all of the algorithms in the Collections class can be applied to
1160	<	* a subList.<p>
1161	<	*
1162	<	* The semantics of the List returned by this method become undefined if
1163	<	* the backing list (i.e., this List) is <i>structurally modified</i> in
1164	<	* any way other than via the returned List.  (Structural modifications are
1165	<	* those that change the size of the List, or otherwise perturb it in such
1166	<	* a fashion that iterations in progress may yield incorrect results.)
1167	<	*
1168	<	* @param fromIndex low endpoint (inclusive) of the subList
1169	<	* @param toIndex high endpoint (exclusive) of the subList
1170	<	* @return a view of the specified range within this List
1171	<	* @throws IndexOutOfBoundsException endpoint index value out of range
1172	<	*         <code>(fromIndex &lt; 0 || toIndex &gt; size)</code>
1173	<	* @throws IllegalArgumentException endpoint indices out of order
1174	<	*         <code>(fromIndex &gt; toIndex)</code>
1175	<	*/
1176	<	public synchronized List<E> subList(int fromIndex, int toIndex) {
1177	<	return new VectorSubList(this, this, fromIndex, fromIndex, toIndex);
1178	<	}
1179	<
1180	<	/**
1181	<	* This class specializes the AbstractList version of SubList to
1182	<	* avoid the double-indirection penalty that would arise using a
1183	<	* synchronized wrapper, as well as to avoid some unnecessary
1184	<	* checks in sublist iterators.
1185	<	*/
1186	<	private static final class VectorSubList<E> extends AbstractList<E> implements RandomAccess {
1187	<	final Vector<E> base;             // base list
1188	<	final AbstractList<E> parent;     // Creating list
1189	<	final int baseOffset;             // index wrt Vector
1190	<	final int parentOffset;           // index wrt parent
1191	<	int length;                       // length of sublist
1192	<
1193	<	VectorSubList(Vector<E> base, AbstractList<E> parent, int baseOffset,
1194	<	int fromIndex, int toIndex) {
1195	<	if (fromIndex < 0)
1196	<	throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
1197	<	if (toIndex > parent.size())
1198	<	throw new IndexOutOfBoundsException("toIndex = " + toIndex);
1199	<	if (fromIndex > toIndex)
1200	<	throw new IllegalArgumentException("fromIndex(" + fromIndex +
1201	<	") > toIndex(" + toIndex + ")");
1202	<
1203	<	this.base = base;
1204	<	this.parent = parent;
1205	<	this.baseOffset = baseOffset;
1206	<	this.parentOffset = fromIndex;
1207	<	this.length = toIndex - fromIndex;
1208	<	modCount = base.modCount;
1209	<	}
1210	<
1211	<	/**
1212	<	* Returns an IndexOutOfBoundsException with nicer message
1213	<	*/
1214	<	private IndexOutOfBoundsException indexError(int index) {
1215	<	return new IndexOutOfBoundsException("Index: " + index +
1216	<	", Size: " + length);
1217	<	}
1218	<
1219	<	public E set(int index, E element) {
1220	<	synchronized(base) {
1221	<	if (index < 0 || index >= length)
1222	<	throw indexError(index);
1223	<	if (base.modCount != modCount)
1224	<	throw new ConcurrentModificationException();
1225	<	return base.set(index + baseOffset, element);
1226	<	}
1227	<	}
1228	<
1229	<	public E get(int index) {
1230	<	synchronized(base) {
1231	<	if (index < 0 || index >= length)
1232	<	throw indexError(index);
1233	<	if (base.modCount != modCount)
1234	<	throw new ConcurrentModificationException();
1235	<	return base.get(index + baseOffset);
1236	<	}
1237	<	}
1238	<
1239	<	public int size() {
1240	<	synchronized(base) {
1241	<	if (base.modCount != modCount)
1242	<	throw new ConcurrentModificationException();
1243	<	return length;
1244	<	}
1245	<	}
1246	<
1247	<	public void add(int index, E element) {
1248	<	synchronized(base) {
1249	<	if (index < 0 || index > length)
1250	<	throw indexError(index);
1251	<	if (base.modCount != modCount)
1252	<	throw new ConcurrentModificationException();
1253	<	parent.add(index + parentOffset, element);
1254	<	length++;
1255	<	modCount = base.modCount;
1256	<	}
1257	<	}
1258	<
1259	<	public E remove(int index) {
1260	<	synchronized(base) {
1261	<	if (index < 0 || index >= length)
1262	<	throw indexError(index);
1263	<	if (base.modCount != modCount)
1264	<	throw new ConcurrentModificationException();
1265	<	E result = parent.remove(index + parentOffset);
1266	<	length--;
1267	<	modCount = base.modCount;
1268	<	return result;
1101	>	return elementData(lastRet = i);
1102		}
1103		}
1104
1105	<	protected void removeRange(int fromIndex, int toIndex) {
1106	<	synchronized(base) {
1107	<	if (base.modCount != modCount)
1108	<	throw new ConcurrentModificationException();
1109	<	parent.removeRange(fromIndex + parentOffset,
1110	<	toIndex + parentOffset);
1111	<	length -= (toIndex-fromIndex);
1279	<	modCount = base.modCount;
1105	>	public void remove() {
1106	>	if (lastRet == -1)
1107	>	throw new IllegalStateException();
1108	>	synchronized (Vector.this) {
1109	>	checkForComodification();
1110	>	Vector.this.remove(lastRet);
1111	>	expectedModCount = modCount;
1112		}
1113	+	cursor = lastRet;
1114	+	lastRet = -1;
1115		}
1116
1117	<	public boolean addAll(Collection<? extends E> c) {
1118	<	return addAll(length, c);
1119	<	}
1286	<
1287	<	public boolean addAll(int index, Collection<? extends E> c) {
1288	<	synchronized(base) {
1289	<	if (index < 0 || index > length)
1290	<	throw indexError(index);
1291	<	int cSize = c.size();
1292	<	if (cSize==0)
1293	<	return false;
1294	<
1295	<	if (base.modCount != modCount)
1296	<	throw new ConcurrentModificationException();
1297	<	parent.addAll(parentOffset + index, c);
1298	<	modCount = base.modCount;
1299	<	length += cSize;
1300	<	return true;
1301	<	}
1302	<	}
1303	<
1304	<	public boolean equals(Object o) {
1305	<	synchronized(base) {return super.equals(o);}
1306	<	}
1307	<
1308	<	public int hashCode() {
1309	<	synchronized(base) {return super.hashCode();}
1310	<	}
1311	<
1312	<	public int indexOf(Object o) {
1313	<	synchronized(base) {return super.indexOf(o);}
1314	<	}
1315	<
1316	<	public int lastIndexOf(Object o) {
1317	<	synchronized(base) {return super.lastIndexOf(o);}
1117	>	final void checkForComodification() {
1118	>	if (modCount != expectedModCount)
1119	>	throw new ConcurrentModificationException();
1120		}
1121	+	}
1122
1123	<	public List<E> subList(int fromIndex, int toIndex) {
1124	<	return new VectorSubList(base, this, fromIndex + baseOffset,
1125	<	fromIndex, toIndex);
1123	>	/**
1124	>	* An optimized version of AbstractList.ListItr
1125	>	*/
1126	>	final class ListItr extends Itr implements ListIterator<E> {
1127	>	ListItr(int index) {
1128	>	super();
1129	>	cursor = index;
1130		}
1131
1132	<	public Iterator<E> iterator() {
1133	<	synchronized(base) {
1327	<	return new VectorSubListIterator(this, 0);
1328	<	}
1132	>	public boolean hasPrevious() {
1133	>	return cursor != 0;
1134		}
1135
1136	<	public synchronized ListIterator<E> listIterator() {
1137	<	synchronized(base) {
1333	<	return new VectorSubListIterator(this, 0);
1334	<	}
1136	>	public int nextIndex() {
1137	>	return cursor;
1138		}
1139
1140	<	public ListIterator<E> listIterator(int index) {
1141	<	synchronized(base) {
1339	<	if (index < 0 || index > length)
1340	<	throw indexError(index);
1341	<	return new VectorSubListIterator(this, index);
1342	<	}
1140	>	public int previousIndex() {
1141	>	return cursor - 1;
1142		}
1143
1144	<	/**
1145	<	* Same idea as VectorIterator, except routing structural
1146	<	* change operations through the sublist.
1348	<	*/
1349	<	private static final class VectorSubListIterator<E> implements ListIterator<E> {
1350	<	final Vector<E> base;         // base list
1351	<	final VectorSubList<E> outer; // Sublist creating this iteraor
1352	<	final int offset;             // cursor offset wrt base
1353	<	int cursor;                   // Current index
1354	<	int fence;                    // Upper bound on cursor
1355	<	int lastRet;                  // Index of returned element, or -1
1356	<	int expectedModCount;         // Expected modCount of base Vector
1357	<
1358	<	VectorSubListIterator(VectorSubList<E> list, int index) {
1359	<	this.lastRet = -1;
1360	<	this.cursor = index;
1361	<	this.outer = list;
1362	<	this.offset = list.baseOffset;
1363	<	this.fence = list.length;
1364	<	this.base = list.base;
1365	<	this.expectedModCount = base.modCount;
1366	<	}
1367	<
1368	<	public boolean hasNext() {
1369	<	return cursor < fence;
1370	<	}
1371	<
1372	<	public boolean hasPrevious() {
1373	<	return cursor > 0;
1374	<	}
1375	<
1376	<	public int nextIndex() {
1377	<	return cursor;
1378	<	}
1379	<
1380	<	public int previousIndex() {
1381	<	return cursor - 1;
1382	<	}
1383	<
1384	<	public E next() {
1385	<	int i = cursor;
1386	<	if (cursor >= fence)
1387	<	throw new NoSuchElementException();
1388	<	Object next = base.iteratorGet(i + offset, expectedModCount);
1389	<	lastRet = i;
1390	<	cursor = i + 1;
1391	<	return (E)next;
1392	<	}
1393	<
1394	<	public E previous() {
1144	>	public E previous() {
1145	>	synchronized (Vector.this) {
1146	>	checkForComodification();
1147		int i = cursor - 1;
1148		if (i < 0)
1149		throw new NoSuchElementException();
1398	–	Object prev = base.iteratorGet(i + offset, expectedModCount);
1399	–	lastRet = i;
1150		cursor = i;
1151	<	return (E)prev;
1402	<	}
1403	<
1404	<	public void set(E e) {
1405	<	if (lastRet < 0)
1406	<	throw new IllegalStateException();
1407	<	if (base.modCount != expectedModCount)
1408	<	throw new ConcurrentModificationException();
1409	<	try {
1410	<	outer.set(lastRet, e);
1411	<	expectedModCount = base.modCount;
1412	<	} catch (IndexOutOfBoundsException ex) {
1413	<	throw new ConcurrentModificationException();
1414	<	}
1151	>	return elementData(lastRet = i);
1152		}
1153	+	}
1154
1155	<	public void remove() {
1156	<	int i = lastRet;
1157	<	if (i < 0)
1158	<	throw new IllegalStateException();
1159	<	if (base.modCount != expectedModCount)
1160	<	throw new ConcurrentModificationException();
1423	<	try {
1424	<	outer.remove(i);
1425	<	if (i < cursor)
1426	<	cursor--;
1427	<	lastRet = -1;
1428	<	fence = outer.length;
1429	<	expectedModCount = base.modCount;
1430	<	} catch (IndexOutOfBoundsException ex) {
1431	<	throw new ConcurrentModificationException();
1432	<	}
1155	>	public void set(E e) {
1156	>	if (lastRet == -1)
1157	>	throw new IllegalStateException();
1158	>	synchronized (Vector.this) {
1159	>	checkForComodification();
1160	>	Vector.this.set(lastRet, e);
1161		}
1162	+	}
1163
1164	<	public void add(E e) {
1165	<	if (base.modCount != expectedModCount)
1166	<	throw new ConcurrentModificationException();
1167	<	try {
1168	<	int i = cursor;
1169	<	outer.add(i, e);
1441	<	cursor = i + 1;
1442	<	lastRet = -1;
1443	<	fence = outer.length;
1444	<	expectedModCount = base.modCount;
1445	<	} catch (IndexOutOfBoundsException ex) {
1446	<	throw new ConcurrentModificationException();
1447	<	}
1164	>	public void add(E e) {
1165	>	int i = cursor;
1166	>	synchronized (Vector.this) {
1167	>	checkForComodification();
1168	>	Vector.this.add(i, e);
1169	>	expectedModCount = modCount;
1170		}
1171	+	cursor = i + 1;
1172	+	lastRet = -1;
1173		}
1174		}
1175		}
1452	–
1453	–
1454	–

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines