[ViewVC] Diff of: jsr166/jsr166/src/main/java/util/Vector.java

Comparing jsr166/src/main/java/util/Vector.java (file contents):
Revision 1.8 by jsr166, Tue Feb 7 20:54:24 2006 UTC vs.
Revision 1.20 by jsr166, Sun Jan 7 07:38:27 2007 UTC

#	Line 1 \| Line 1
1		/*
2		* %W% %E%
3		*
4	<	* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
4	>	* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
5		* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6		*/
7
8		package java.util;
9
10		/**
11	<	* The <code>Vector</code> class implements a growable array of
11	>	* The {@code Vector} class implements a growable array of
12		* objects. Like an array, it contains components that can be
13		* accessed using an integer index. However, the size of a
14	<	* <code>Vector</code> can grow or shrink as needed to accommodate
15	<	* adding and removing items after the <code>Vector</code> has been created.<p>
14	>	* {@code Vector} can grow or shrink as needed to accommodate
15	>	* adding and removing items after the {@code Vector} has been created.
16		*
17	<	* Each vector tries to optimize storage management by maintaining a
18	<	* <code>capacity</code> and a <code>capacityIncrement</code>. The
19	<	* <code>capacity</code> is always at least as large as the vector
17	>	* <p>Each vector tries to optimize storage management by maintaining a
18	>	* {@code capacity} and a {@code capacityIncrement}. The
19	>	* {@code capacity} is always at least as large as the vector
20		* size; it is usually larger because as components are added to the
21		* vector, the vector's storage increases in chunks the size of
22	<	* <code>capacityIncrement</code>. An application can increase the
22	>	* {@code capacityIncrement}. An application can increase the
23		* capacity of a vector before inserting a large number of
24	<	* components; this reduces the amount of incremental reallocation. <p>
24	>	* components; this reduces the amount of incremental reallocation.
25		*
26	<	* As of the Java 2 platform v1.2, this class has been retrofitted to
27	<	* implement List, so that it becomes a part of Java's collection framework.
28	<	* Unlike the new collection implementations, Vector is synchronized.<p>
29	<	*
30	<	* The Iterators returned by Vector's iterator and listIterator
26	>	* <p>The Iterators returned by Vector's iterator and listIterator
27		* methods are <em>fail-fast</em>: if the Vector is structurally modified
28		* at any time after the Iterator is created, in any way except through the
29		* Iterator's own remove or add methods, the Iterator will throw a
#	Line 40 \| Line 36 \| package java.util;
36		* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
37		* as it is, generally speaking, impossible to make any hard guarantees in the
38		* presence of unsynchronized concurrent modification. Fail-fast iterators
39	<	* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
39	>	* throw {@code ConcurrentModificationException} on a best-effort basis.
40		* Therefore, it would be wrong to write a program that depended on this
41		* exception for its correctness: <i>the fail-fast behavior of iterators
42	<	* should be used only to detect bugs.</i><p>
42	>	* should be used only to detect bugs.</i>
43		*
44	<	* This class is a member of the
45	<	* <a href="{@docRoot}/../guide/collections/index.html">
46	<	* Java Collections Framework</a>.
44	>	* <p>As of the Java 2 platform v1.2, this class was retrofitted to
45	>	* implement the {@link List} interface, making it a member of the
46	>	* <a href="{@docRoot}/../technotes/guides/collections/index.html"> Java
47	>	* Collections Framework</a>. Unlike the new collection
48	>	* implementations, {@code Vector} is synchronized.
49		*
50		* @author Lee Boynton
51		* @author Jonathan Payne
#	Line 65 \| Line 63 \| public class Vector<E>
63		/**
64		* The array buffer into which the components of the vector are
65		* stored. The capacity of the vector is the length of this array buffer,
66	<	* and is at least large enough to contain all the vector's elements.<p>
66	>	* and is at least large enough to contain all the vector's elements.
67		*
68	<	* Any array elements following the last element in the Vector are null.
68	>	* <p>Any array elements following the last element in the Vector are null.
69		*
70		* @serial
71		*/
72		protected Object[] elementData;
73
74		/**
75	<	* The number of valid components in this <tt>Vector</tt> object.
76	<	* Components <tt>elementData[0]</tt> through
77	<	* <tt>elementData[elementCount-1]</tt> are the actual items.
75	>	* The number of valid components in this {@code Vector} object.
76	>	* Components {@code elementData[0]} through
77	>	* {@code elementData[elementCount-1]} are the actual items.
78		*
79		* @serial
80		*/
#	Line 102 \| Line 100 \| public class Vector<E>
100		* @param initialCapacity the initial capacity of the vector
101		* @param capacityIncrement the amount by which the capacity is
102		* increased when the vector overflows
103	<	* @exception IllegalArgumentException if the specified initial capacity
104	<	* is negative
103	>	* @throws IllegalArgumentException if the specified initial capacity
104	>	* is negative
105		*/
106		public Vector(int initialCapacity, int capacityIncrement) {
107		super();
#	Line 119 \| Line 117 \| public class Vector<E>
117		* with its capacity increment equal to zero.
118		*
119		* @param initialCapacity the initial capacity of the vector
120	<	* @exception IllegalArgumentException if the specified initial capacity
121	<	* is negative
120	>	* @throws IllegalArgumentException if the specified initial capacity
121	>	* is negative
122		*/
123		public Vector(int initialCapacity) {
124		this(initialCapacity, 0);
#	Line 128 \| Line 126 \| public class Vector<E>
126
127		/**
128		* Constructs an empty vector so that its internal data array
129	<	* has size <tt>10</tt> and its standard capacity increment is
129	>	* has size {@code 10} and its standard capacity increment is
130		* zero.
131		*/
132		public Vector() {
#	Line 155 \| Line 153 \| public class Vector<E>
153
154		/**
155		* Copies the components of this vector into the specified array.
156	<	* The item at index <tt>k</tt> in this vector is copied into
157	<	* component <tt>k</tt> of <tt>anArray</tt>.
156	>	* The item at index {@code k} in this vector is copied into
157	>	* component {@code k} of {@code anArray}.
158		*
159		* @param anArray the array into which the components get copied
160		* @throws NullPointerException if the given array is null
#	Line 174 \| Line 172 \| public class Vector<E>
172		* Trims the capacity of this vector to be the vector's current
173		* size. If the capacity of this vector is larger than its current
174		* size, then the capacity is changed to equal the size by replacing
175	<	* its internal data array, kept in the field <tt>elementData</tt>,
175	>	* its internal data array, kept in the field {@code elementData},
176		* with a smaller one. An application can use this operation to
177		* minimize the storage of a vector.
178		*/
#	Line 192 \| Line 190 \| public class Vector<E>
190		* the minimum capacity argument.
191		*
192		* <p>If the current capacity of this vector is less than
193	<	* <tt>minCapacity</tt>, then its capacity is increased by replacing its
194	<	* internal data array, kept in the field <tt>elementData</tt>, with a
193	>	* {@code minCapacity}, then its capacity is increased by replacing its
194	>	* internal data array, kept in the field {@code elementData}, with a
195		* larger one. The size of the new data array will be the old size plus
196	<	* <tt>capacityIncrement</tt>, unless the value of
197	<	* <tt>capacityIncrement</tt> is less than or equal to zero, in which case
196	>	* {@code capacityIncrement}, unless the value of
197	>	* {@code capacityIncrement} is less than or equal to zero, in which case
198		* the new capacity will be twice the old capacity; but if this new size
199	<	* is still smaller than <tt>minCapacity</tt>, then the new capacity will
200	<	* be <tt>minCapacity</tt>.
199	>	* is still smaller than {@code minCapacity}, then the new capacity will
200	>	* be {@code minCapacity}.
201		*
202		* @param minCapacity the desired minimum capacity
203		*/
#	Line 214 \| Line 212 \| public class Vector<E>
212		* method for ensuring capacity without incurring the cost of an
213		* extra synchronization.
214		*
215	<	* @see java.util.Vector#ensureCapacity(int)
215	>	* @see #ensureCapacity(int)
216		*/
217		private void ensureCapacityHelper(int minCapacity) {
218		int oldCapacity = elementData.length;
#	Line 231 \| Line 229 \| public class Vector<E>
229
230		/**
231		* Sets the size of this vector. If the new size is greater than the
232	<	* current size, new <code>null</code> items are added to the end of
232	>	* current size, new {@code null} items are added to the end of
233		* the vector. If the new size is less than the current size, all
234	<	* components at index <code>newSize</code> and greater are discarded.
234	>	* components at index {@code newSize} and greater are discarded.
235		*
236	<	* @param newSize the new size of this vector
237	<	* @throws ArrayIndexOutOfBoundsException if new size is negative
236	>	* @param newSize the new size of this vector
237	>	* @throws ArrayIndexOutOfBoundsException if the new size is negative
238		*/
239		public synchronized void setSize(int newSize) {
240		modCount++;
#	Line 254 \| Line 252 \| public class Vector<E>
252		* Returns the current capacity of this vector.
253		*
254		* @return the current capacity (the length of its internal
255	<	* data array, kept in the field <tt>elementData</tt>
255	>	* data array, kept in the field {@code elementData}
256		* of this vector)
257		*/
258		public synchronized int capacity() {
#	Line 273 \| Line 271 \| public class Vector<E>
271		/**
272		* Tests if this vector has no components.
273		*
274	<	* @return <code>true</code> if and only if this vector has
274	>	* @return {@code true} if and only if this vector has
275		* no components, that is, its size is zero;
276	<	* <code>false</code> otherwise.
276	>	* {@code false} otherwise.
277		*/
278		public synchronized boolean isEmpty() {
279		return elementCount == 0;
#	Line 283 \| Line 281 \| public class Vector<E>
281
282		/**
283		* Returns an enumeration of the components of this vector. The
284	<	* returned <tt>Enumeration</tt> object will generate all items in
285	<	* this vector. The first item generated is the item at index <tt>0</tt>,
286	<	* then the item at index <tt>1</tt>, and so on.
284	>	* returned {@code Enumeration} object will generate all items in
285	>	* this vector. The first item generated is the item at index {@code 0},
286	>	* then the item at index {@code 1}, and so on.
287		*
288		* @return an enumeration of the components of this vector
291	–	* @see Enumeration
289		* @see Iterator
290		*/
291		public Enumeration<E> elements() {
#	Line 311 \| Line 308 \| public class Vector<E>
308		}
309
310		/**
311	<	* Returns <tt>true</tt> if this vector contains the specified element.
312	<	* More formally, returns <tt>true</tt> if and only if this vector
313	<	* contains at least one element <tt>e</tt> such that
311	>	* Returns {@code true} if this vector contains the specified element.
312	>	* More formally, returns {@code true} if and only if this vector
313	>	* contains at least one element {@code e} such that
314		* <tt>(o==null ? e==null : o.equals(e))</tt>.
315		*
316		* @param o element whose presence in this vector is to be tested
317	<	* @return <tt>true</tt> if this vector contains the specified element
317	>	* @return {@code true} if this vector contains the specified element
318		*/
319		public boolean contains(Object o) {
320		return indexOf(o, 0) >= 0;
#	Line 326 \| Line 323 \| public class Vector<E>
323		/**
324		* Returns the index of the first occurrence of the specified element
325		* in this vector, or -1 if this vector does not contain the element.
326	<	* More formally, returns the lowest index <tt>i</tt> such that
326	>	* More formally, returns the lowest index {@code i} such that
327		* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
328		* or -1 if there is no such index.
329		*
#	Line 340 \| Line 337 \| public class Vector<E>
337
338		/**
339		* Returns the index of the first occurrence of the specified element in
340	<	* this vector, searching forwards from <tt>index</tt>, or returns -1 if
340	>	* this vector, searching forwards from {@code index}, or returns -1 if
341		* the element is not found.
342	<	* More formally, returns the lowest index <tt>i</tt> such that
342	>	* More formally, returns the lowest index {@code i} such that
343		* <tt>(i >= index && (o==null ? get(i)==null : o.equals(get(i))))</tt>,
344		* or -1 if there is no such index.
345		*
346		* @param o element to search for
347		* @param index index to start searching from
348		* @return the index of the first occurrence of the element in
349	<	* this vector at position <tt>index</tt> or later in the vector;
350	<	* <tt>-1</tt> if the element is not found.
349	>	* this vector at position {@code index} or later in the vector;
350	>	* {@code -1} if the element is not found.
351		* @throws IndexOutOfBoundsException if the specified index is negative
352		* @see Object#equals(Object)
353		*/
#	Line 370 \| Line 367 \| public class Vector<E>
367		/**
368		* Returns the index of the last occurrence of the specified element
369		* in this vector, or -1 if this vector does not contain the element.
370	<	* More formally, returns the highest index <tt>i</tt> such that
370	>	* More formally, returns the highest index {@code i} such that
371		* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
372		* or -1 if there is no such index.
373		*
#	Line 384 \| Line 381 \| public class Vector<E>
381
382		/**
383		* Returns the index of the last occurrence of the specified element in
384	<	* this vector, searching backwards from <tt>index</tt>, or returns -1 if
384	>	* this vector, searching backwards from {@code index}, or returns -1 if
385		* the element is not found.
386	<	* More formally, returns the highest index <tt>i</tt> such that
386	>	* More formally, returns the highest index {@code i} such that
387		* <tt>(i <= index && (o==null ? get(i)==null : o.equals(get(i))))</tt>,
388		* or -1 if there is no such index.
389		*
390		* @param o element to search for
391		* @param index index to start searching backwards from
392		* @return the index of the last occurrence of the element at position
393	<	* less than or equal to <tt>index</tt> in this vector;
393	>	* less than or equal to {@code index} in this vector;
394		* -1 if the element is not found.
395		* @throws IndexOutOfBoundsException if the specified index is greater
396		* than or equal to the current size of this vector
#	Line 415 \| Line 412 \| public class Vector<E>
412		}
413
414		/**
415	<	* Returns the component at the specified index.<p>
415	>	* Returns the component at the specified index.
416		*
417	<	* This method is identical in functionality to the get method
418	<	* (which is part of the List interface).
417	>	* <p>This method is identical in functionality to the {@link #get(int)}
418	>	* method (which is part of the {@link List} interface).
419		*
420		* @param index an index into this vector
421		* @return the component at the specified index
422	<	* @exception ArrayIndexOutOfBoundsException if the <tt>index</tt>
423	<	* is negative or not less than the current size of this
427	<	* <tt>Vector</tt> object.
428	<	* @see #get(int)
429	<	* @see List
422	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
423	>	* ({@code index < 0 \|\| index >= size()})
424		*/
425		public synchronized E elementAt(int index) {
426		if (index >= elementCount) {
#	Line 437 \| Line 431 \| public class Vector<E>
431		}
432
433		/**
434	<	* Returns the first component (the item at index <tt>0</tt>) of
434	>	* Returns the first component (the item at index {@code 0}) of
435		* this vector.
436		*
437		* @return the first component of this vector
438	<	* @exception NoSuchElementException if this vector has no components
438	>	* @throws NoSuchElementException if this vector has no components
439		*/
440		public synchronized E firstElement() {
441		if (elementCount == 0) {
#	Line 455 \| Line 449 \| public class Vector<E>
449		*
450		* @return the last component of the vector, i.e., the component at index
451		* <code>size() - 1</code>.
452	<	* @exception NoSuchElementException if this vector is empty
452	>	* @throws NoSuchElementException if this vector is empty
453		*/
454		public synchronized E lastElement() {
455		if (elementCount == 0) {
#	Line 465 \| Line 459 \| public class Vector<E>
459		}
460
461		/**
462	<	* Sets the component at the specified <code>index</code> of this
462	>	* Sets the component at the specified {@code index} of this
463		* vector to be the specified object. The previous component at that
464	<	* position is discarded.<p>
464	>	* position is discarded.
465		*
466	<	* The index must be a value greater than or equal to <code>0</code>
467	<	* and less than the current size of the vector. <p>
466	>	* <p>The index must be a value greater than or equal to {@code 0}
467	>	* and less than the current size of the vector.
468		*
469	<	* This method is identical in functionality to the set method
470	<	* (which is part of the List interface). Note that the set method reverses
471	<	* the order of the parameters, to more closely match array usage. Note
472	<	* also that the set method returns the old value that was stored at the
473	<	* specified position.
469	>	* <p>This method is identical in functionality to the
470	>	* {@link #set(int, Object) set(int, E)}
471	>	* method (which is part of the {@link List} interface). Note that the
472	>	* {@code set} method reverses the order of the parameters, to more closely
473	>	* match array usage. Note also that the {@code set} method returns the
474	>	* old value that was stored at the specified position.
475		*
476		* @param obj what the component is to be set to
477		* @param index the specified index
478	<	* @exception ArrayIndexOutOfBoundsException if the index was invalid
479	<	* @see #size()
485	<	* @see List
486	<	* @see #set(int, java.lang.Object)
478	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
479	>	* ({@code index < 0 \|\| index >= size()})
480		*/
481		public synchronized void setElementAt(E obj, int index) {
482		if (index >= elementCount) {
#	Line 496 \| Line 489 \| public class Vector<E>
489		/**
490		* Deletes the component at the specified index. Each component in
491		* this vector with an index greater or equal to the specified
492	<	* <code>index</code> is shifted downward to have an index one
492	>	* {@code index} is shifted downward to have an index one
493		* smaller than the value it had previously. The size of this vector
494	<	* is decreased by <tt>1</tt>.<p>
494	>	* is decreased by {@code 1}.
495		*
496	<	* The index must be a value greater than or equal to <code>0</code>
497	<	* and less than the current size of the vector. <p>
496	>	* <p>The index must be a value greater than or equal to {@code 0}
497	>	* and less than the current size of the vector.
498		*
499	<	* This method is identical in functionality to the remove method
500	<	* (which is part of the List interface). Note that the remove method
501	<	* returns the old value that was stored at the specified position.
499	>	* <p>This method is identical in functionality to the {@link #remove(int)}
500	>	* method (which is part of the {@link List} interface). Note that the
501	>	* {@code remove} method returns the old value that was stored at the
502	>	* specified position.
503		*
504		* @param index the index of the object to remove
505	<	* @exception ArrayIndexOutOfBoundsException if the index was invalid
506	<	* @see #size()
513	<	* @see #remove(int)
514	<	* @see List
505	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
506	>	* ({@code index < 0 \|\| index >= size()})
507		*/
508		public synchronized void removeElementAt(int index) {
509		modCount++;
#	Line 532 \| Line 524 \| public class Vector<E>
524
525		/**
526		* Inserts the specified object as a component in this vector at the
527	<	* specified <code>index</code>. Each component in this vector with
528	<	* an index greater or equal to the specified <code>index</code> is
527	>	* specified {@code index}. Each component in this vector with
528	>	* an index greater or equal to the specified {@code index} is
529		* shifted upward to have an index one greater than the value it had
530	<	* previously. <p>
530	>	* previously.
531		*
532	<	* The index must be a value greater than or equal to <code>0</code>
532	>	* <p>The index must be a value greater than or equal to {@code 0}
533		* and less than or equal to the current size of the vector. (If the
534		* index is equal to the current size of the vector, the new element
535	<	* is appended to the Vector.)<p>
535	>	* is appended to the Vector.)
536		*
537	<	* This method is identical in functionality to the add(Object, int) method
538	<	* (which is part of the List interface). Note that the add method reverses
539	<	* the order of the parameters, to more closely match array usage.
537	>	* <p>This method is identical in functionality to the
538	>	* {@link #add(int, Object) add(int, E)}
539	>	* method (which is part of the {@link List} interface). Note that the
540	>	* {@code add} method reverses the order of the parameters, to more closely
541	>	* match array usage.
542		*
543		* @param obj the component to insert
544		* @param index where to insert the new component
545	<	* @exception ArrayIndexOutOfBoundsException if the index was invalid
546	<	* @see #size()
553	<	* @see #add(int, Object)
554	<	* @see List
545	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
546	>	* ({@code index < 0 \|\| index > size()})
547		*/
548		public synchronized void insertElementAt(E obj, int index) {
549		modCount++;
#	Line 568 \| Line 560 \| public class Vector<E>
560		/**
561		* Adds the specified component to the end of this vector,
562		* increasing its size by one. The capacity of this vector is
563	<	* increased if its size becomes greater than its capacity. <p>
563	>	* increased if its size becomes greater than its capacity.
564		*
565	<	* This method is identical in functionality to the add(Object) method
566	<	* (which is part of the List interface).
565	>	* <p>This method is identical in functionality to the
566	>	* {@link #add(Object) add(E)}
567	>	* method (which is part of the {@link List} interface).
568		*
569		* @param obj the component to be added
577	–	* @see #add(Object)
578	–	* @see List
570		*/
571		public synchronized void addElement(E obj) {
572		modCount++;
#	Line 588 \| Line 579 \| public class Vector<E>
579		* from this vector. If the object is found in this vector, each
580		* component in the vector with an index greater or equal to the
581		* object's index is shifted downward to have an index one smaller
582	<	* than the value it had previously.<p>
582	>	* than the value it had previously.
583		*
584	<	* This method is identical in functionality to the remove(Object)
585	<	* method (which is part of the List interface).
584	>	* <p>This method is identical in functionality to the
585	>	* {@link #remove(Object)} method (which is part of the
586	>	* {@link List} interface).
587		*
588		* @param obj the component to be removed
589	<	* @return <code>true</code> if the argument was a component of this
590	<	* vector; <code>false</code> otherwise.
599	<	* @see List#remove(Object)
600	<	* @see List
589	>	* @return {@code true} if the argument was a component of this
590	>	* vector; {@code false} otherwise.
591		*/
592		public synchronized boolean removeElement(Object obj) {
593		modCount++;
#	Line 610 \| Line 600 \| public class Vector<E>
600		}
601
602		/**
603	<	* Removes all components from this vector and sets its size to zero.<p>
603	>	* Removes all components from this vector and sets its size to zero.
604		*
605	<	* This method is identical in functionality to the clear method
606	<	* (which is part of the List interface).
617	<	*
618	<	* @see #clear
619	<	* @see List
605	>	* <p>This method is identical in functionality to the {@link #clear}
606	>	* method (which is part of the {@link List} interface).
607		*/
608		public synchronized void removeAllElements() {
609		modCount++;
#	Line 630 \| Line 617 \| public class Vector<E>
617		/**
618		* Returns a clone of this vector. The copy will contain a
619		* reference to a clone of the internal data array, not a reference
620	<	* to the original internal data array of this <tt>Vector</tt> object.
620	>	* to the original internal data array of this {@code Vector} object.
621		*
622		* @return a clone of this vector
623		*/
#	Line 661 \| Line 648 \| public class Vector<E>
648		* correct order; the runtime type of the returned array is that of the
649		* specified array. If the Vector fits in the specified array, it is
650		* returned therein. Otherwise, a new array is allocated with the runtime
651	<	* type of the specified array and the size of this Vector.<p>
651	>	* type of the specified array and the size of this Vector.
652		*
653	<	* If the Vector fits in the specified array with room to spare
653	>	* <p>If the Vector fits in the specified array with room to spare
654		* (i.e., the array has more elements than the Vector),
655		* the element in the array immediately following the end of the
656		* Vector is set to null. (This is useful in determining the length
#	Line 674 \| Line 661 \| public class Vector<E>
661		* be stored, if it is big enough; otherwise, a new array of the
662		* same runtime type is allocated for this purpose.
663		* @return an array containing the elements of the Vector
664	<	* @exception ArrayStoreException the runtime type of a is not a supertype
664	>	* @throws ArrayStoreException if the runtime type of a is not a supertype
665		* of the runtime type of every element in this Vector
666		* @throws NullPointerException if the given array is null
667		* @since 1.2
#	Line 698 \| Line 685 \| public class Vector<E>
685		*
686		* @param index index of the element to return
687		* @return object at the specified index
688	<	* @exception ArrayIndexOutOfBoundsException index is out of range (index
689	<	* < 0 \|\| index >= size())
688	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
689	>	* ({@code index < 0 \|\| index >= size()})
690		* @since 1.2
691		*/
692		public synchronized E get(int index) {
#	Line 716 \| Line 703 \| public class Vector<E>
703		* @param index index of the element to replace
704		* @param element element to be stored at the specified position
705		* @return the element previously at the specified position
706	<	* @exception ArrayIndexOutOfBoundsException index out of range
707	<	* (index < 0 \|\| index >= size())
706	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
707	>	* ({@code index < 0 \|\| index >= size()})
708		* @since 1.2
709		*/
710		public synchronized E set(int index, E element) {
#	Line 733 \| Line 720 \| public class Vector<E>
720		* Appends the specified element to the end of this Vector.
721		*
722		* @param e element to be appended to this Vector
723	<	* @return <tt>true</tt> (as specified by {@link Collection#add})
723	>	* @return {@code true} (as specified by {@link Collection#add})
724		* @since 1.2
725		*/
726		public synchronized boolean add(E e) {
#	Line 747 \| Line 734 \| public class Vector<E>
734		* Removes the first occurrence of the specified element in this Vector
735		* If the Vector does not contain the element, it is unchanged. More
736		* formally, removes the element with the lowest index i such that
737	<	* <code>(o==null ? get(i)==null : o.equals(get(i)))</code> (if such
737	>	* {@code (o==null ? get(i)==null : o.equals(get(i)))} (if such
738		* an element exists).
739		*
740		* @param o element to be removed from this Vector, if present
#	Line 765 \| Line 752 \| public class Vector<E>
752		*
753		* @param index index at which the specified element is to be inserted
754		* @param element element to be inserted
755	<	* @exception ArrayIndexOutOfBoundsException index is out of range
756	<	* (index < 0 \|\| index > size())
755	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
756	>	* ({@code index < 0 \|\| index > size()})
757		* @since 1.2
758		*/
759		public void add(int index, E element) {
#	Line 778 \| Line 765 \| public class Vector<E>
765		* Shifts any subsequent elements to the left (subtracts one from their
766		* indices). Returns the element that was removed from the Vector.
767		*
768	<	* @exception ArrayIndexOutOfBoundsException index out of range (index
769	<	* < 0 \|\| index >= size())
768	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
769	>	* ({@code index < 0 \|\| index >= size()})
770		* @param index the index of the element to be removed
771		* @return element that was removed
772		* @since 1.2
#	Line 834 \| Line 821 \| public class Vector<E>
821		* specified Collection is this Vector, and this Vector is nonempty.)
822		*
823		* @param c elements to be inserted into this Vector
824	<	* @return <tt>true</tt> if this Vector changed as a result of the call
824	>	* @return {@code true} if this Vector changed as a result of the call
825		* @throws NullPointerException if the specified collection is null
826		* @since 1.2
827		*/
#	Line 897 \| Line 884 \| public class Vector<E>
884		* @param index index at which to insert the first element from the
885		* specified collection
886		* @param c elements to be inserted into this Vector
887	<	* @return <tt>true</tt> if this Vector changed as a result of the call
888	<	* @exception ArrayIndexOutOfBoundsException index out of range (index
889	<	* < 0 \|\| index > size())
887	>	* @return {@code true} if this Vector changed as a result of the call
888	>	* @throws ArrayIndexOutOfBoundsException if the index is out of range
889	>	* ({@code index < 0 \|\| index > size()})
890		* @throws NullPointerException if the specified collection is null
891		* @since 1.2
892		*/
#	Line 926 \| Line 913 \| public class Vector<E>
913		* Compares the specified Object with this Vector for equality. Returns
914		* true if and only if the specified Object is also a List, both Lists
915		* have the same size, and all corresponding pairs of elements in the two
916	<	* Lists are <em>equal</em>. (Two elements <code>e1</code> and
917	<	* <code>e2</code> are <em>equal</em> if <code>(e1==null ? e2==null :
918	<	* e1.equals(e2))</code>.) In other words, two Lists are defined to be
916	>	* Lists are <em>equal</em>. (Two elements {@code e1} and
917	>	* {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
918	>	* e1.equals(e2))}.) In other words, two Lists are defined to be
919		* equal if they contain the same elements in the same order.
920		*
921		* @param o the Object to be compared for equality with this Vector
#	Line 954 \| Line 941 \| public class Vector<E>
941		}
942
943		/**
957	–	* Returns a view of the portion of this List between fromIndex,
958	–	* inclusive, and toIndex, exclusive. (If fromIndex and toIndex are
959	–	* equal, the returned List is empty.) The returned List is backed by this
960	–	* List, so changes in the returned List are reflected in this List, and
961	–	* vice-versa. The returned List supports all of the optional List
962	–	* operations supported by this List.<p>
963	–	*
964	–	* This method eliminates the need for explicit range operations (of
965	–	* the sort that commonly exist for arrays). Any operation that expects
966	–	* a List can be used as a range operation by operating on a subList view
967	–	* instead of a whole List. For example, the following idiom
968	–	* removes a range of elements from a List:
969	–	* <pre>
970	–	* list.subList(from, to).clear();
971	–	* </pre>
972	–	* Similar idioms may be constructed for indexOf and lastIndexOf,
973	–	* and all of the algorithms in the Collections class can be applied to
974	–	* a subList.<p>
975	–	*
976	–	* The semantics of the List returned by this method become undefined if
977	–	* the backing list (i.e., this List) is <i>structurally modified</i> in
978	–	* any way other than via the returned List. (Structural modifications are
979	–	* those that change the size of the List, or otherwise perturb it in such
980	–	* a fashion that iterations in progress may yield incorrect results.)
981	–	*
982	–	* @param fromIndex low endpoint (inclusive) of the subList
983	–	* @param toIndex high endpoint (exclusive) of the subList
984	–	* @return a view of the specified range within this List
985	–	* @throws IndexOutOfBoundsException endpoint index value out of range
986	–	* <code>(fromIndex < 0 \|\| toIndex > size)</code>
987	–	* @throws IllegalArgumentException endpoint indices out of order
988	–	* <code>(fromIndex > toIndex)</code>
989	–	*/
990	–	public synchronized List<E> subList(int fromIndex, int toIndex) {
991	–	return Collections.synchronizedList(super.subList(fromIndex, toIndex),
992	–	this);
993	–	}
994	–
995	–	/**
944		* Removes from this List all of the elements whose index is between
945		* fromIndex, inclusive and toIndex, exclusive. Shifts any succeeding
946		* elements to the left (reduces their index).
947	<	* This call shortens the ArrayList by (toIndex - fromIndex) elements. (If
947	>	* This call shortens the Vector by (toIndex - fromIndex) elements. (If
948		* toIndex==fromIndex, this operation has no effect.)
949		*
950		* @param fromIndex index of first element to be removed
#	Line 1015 \| Line 963 \| public class Vector<E>
963		}
964
965		/**
966	<	* Save the state of the <tt>Vector</tt> instance to a stream (that
966	>	* Save the state of the {@code Vector} instance to a stream (that
967		* is, serialize it). This method is present merely for synchronization.
968		* It just calls the default writeObject method.
969		*/
#	Line 1028 \| Line 976 \| public class Vector<E>
976		/**
977		* Returns a list-iterator of the elements in this list (in proper
978		* sequence), starting at the specified position in the list.
979	<	* Obeys the general contract of <tt>List.listIterator(int)</tt>.<p>
979	>	* Obeys the general contract of {@link List#listIterator(int)}.
980		*
981	<	* The list-iterator is <i>fail-fast</i>: if the list is structurally
981	>	* <p>The list-iterator is <i>fail-fast</i>: if the list is structurally
982		* modified at any time after the Iterator is created, in any way except
983	<	* through the list-iterator's own <tt>remove</tt> or <tt>add</tt>
983	>	* through the list-iterator's own {@code remove} or {@code add}
984		* methods, the list-iterator will throw a
985	<	* <tt>ConcurrentModificationException</tt>. Thus, in the face of
985	>	* {@code ConcurrentModificationException}. Thus, in the face of
986		* concurrent modification, the iterator fails quickly and cleanly, rather
987		* than risking arbitrary, non-deterministic behavior at an undetermined
988		* time in the future.
989		*
990		* @param index index of the first element to be returned from the
991	<	* list-iterator (by a call to <tt>next</tt>)
992	<	* @return a ListIterator of the elements in this list (in proper
991	>	* list-iterator (by a call to {@link ListIterator#next})
992	>	* @return a list-iterator of the elements in this list (in proper
993		* sequence), starting at the specified position in the list
994		* @throws IndexOutOfBoundsException {@inheritDoc}
1047	–	* @see List#listIterator(int)
995		*/
996		public synchronized ListIterator<E> listIterator(int index) {
997		if (index < 0 \|\| index > elementCount)
998		throw new IndexOutOfBoundsException("Index: "+index);
999	<	return new VectorIterator(index);
999	>	return new VectorIterator(index, elementCount);
1000		}
1001
1002		/**
1003		* {@inheritDoc}
1004		*/
1005		public synchronized ListIterator<E> listIterator() {
1006	<	return new VectorIterator(0);
1006	>	return new VectorIterator(0, elementCount);
1007		}
1008
1009		/**
#	Line 1065 \| Line 1012 \| public class Vector<E>
1012		* @return an iterator over the elements in this list in proper sequence
1013		*/
1014		public synchronized Iterator<E> iterator() {
1015	<	return new VectorIterator(0);
1015	>	return new VectorIterator(0, elementCount);
1016		}
1017
1018		/**
1019	<	* A streamlined version of AbstractList.ListItr.
1019	>	* Helper method to access array elements under synchronization by
1020	>	* iterators. The caller performs index check with respect to
1021	>	* expected bounds, so errors accessing the element are reported
1022	>	* as ConcurrentModificationExceptions.
1023	>	*/
1024	>	final synchronized Object iteratorGet(int index, int expectedModCount) {
1025	>	if (modCount == expectedModCount) {
1026	>	try {
1027	>	return elementData[index];
1028	>	} catch(IndexOutOfBoundsException fallThrough) {
1029	>	}
1030	>	}
1031	>	throw new ConcurrentModificationException();
1032	>	}
1033	>
1034	>	/**
1035	>	* Streamlined specialization of AbstractList version of iterator.
1036	>	* Locally performs bounds checks, but relies on outer Vector
1037	>	* to access elements under synchronization.
1038		*/
1039		private final class VectorIterator implements ListIterator<E> {
1040	<	int cursor; // current position
1041	<	int lastRet; // index of last returned element
1042	<	int expectedModCount; // to check for CME
1043	<
1044	<	VectorIterator(int index) {
1045	<	cursor = index;
1046	<	expectedModCount = modCount;
1047	<	lastRet = -1;
1040	>	int cursor; // Index of next element to return;
1041	>	int fence; // Upper bound on cursor (cache of size())
1042	>	int lastRet; // Index of last element, or -1 if no such
1043	>	int expectedModCount; // To check for CME
1044	>
1045	>	VectorIterator(int index, int fence) {
1046	>	this.cursor = index;
1047	>	this.fence = fence;
1048	>	this.lastRet = -1;
1049	>	this.expectedModCount = Vector.this.modCount;
1050		}
1051
1052		public boolean hasNext() {
1053	<	// Racy but within spec, since modifications are checked
1087	<	// within or after synchronization in next/previous
1088	<	return cursor != elementCount;
1053	>	return cursor < fence;
1054		}
1055
1056		public boolean hasPrevious() {
1057	<	return cursor != 0;
1057	>	return cursor > 0;
1058		}
1059
1060		public int nextIndex() {
#	Line 1101 \| Line 1066 \| public class Vector<E>
1066		}
1067
1068		public E next() {
1069	<	try {
1070	<	int i = cursor;
1106	<	E next = get(i);
1107	<	lastRet = i;
1108	<	cursor = i + 1;
1109	<	return next;
1110	<	} catch (IndexOutOfBoundsException ex) {
1069	>	int i = cursor;
1070	>	if (i >= fence)
1071		throw new NoSuchElementException();
1072	<	} finally {
1073	<	if (expectedModCount != modCount)
1074	<	throw new ConcurrentModificationException();
1075	<	}
1072	>	Object next = Vector.this.iteratorGet(i, expectedModCount);
1073	>	lastRet = i;
1074	>	cursor = i + 1;
1075	>	return (E)next;
1076		}
1077
1078	<	public E previous() {
1079	<	try {
1080	<	int i = cursor - 1;
1121	<	E prev = get(i);
1122	<	lastRet = i;
1123	<	cursor = i;
1124	<	return prev;
1125	<	} catch (IndexOutOfBoundsException ex) {
1078	>	public E previous() {
1079	>	int i = cursor - 1;
1080	>	if (i < 0)
1081		throw new NoSuchElementException();
1082	<	} finally {
1083	<	if (expectedModCount != modCount)
1084	<	throw new ConcurrentModificationException();
1085	<	}
1082	>	Object prev = Vector.this.iteratorGet(i, expectedModCount);
1083	>	lastRet = i;
1084	>	cursor = i;
1085	>	return (E)prev;
1086		}
1087
1088	<	public void remove() {
1089	<	if (lastRet == -1)
1088	>	public void set(E e) {
1089	>	if (lastRet < 0)
1090		throw new IllegalStateException();
1091	<	if (expectedModCount != modCount)
1092	<	throw new ConcurrentModificationException();
1093	<	try {
1094	<	Vector.this.remove(lastRet);
1095	<	if (lastRet < cursor)
1141	<	cursor--;
1142	<	lastRet = -1;
1143	<	expectedModCount = modCount;
1091	>	if (Vector.this.modCount != expectedModCount)
1092	>	throw new ConcurrentModificationException();
1093	>	try {
1094	>	Vector.this.set(lastRet, e);
1095	>	expectedModCount = Vector.this.modCount;
1096		} catch (IndexOutOfBoundsException ex) {
1097		throw new ConcurrentModificationException();
1098		}
1099		}
1100
1101	<	public void set(E e) {
1102	<	if (lastRet == -1)
1101	>	public void remove() {
1102	>	int i = lastRet;
1103	>	if (i < 0)
1104		throw new IllegalStateException();
1105	<	if (expectedModCount != modCount)
1105	>	if (Vector.this.modCount != expectedModCount)
1106		throw new ConcurrentModificationException();
1107	<	try {
1108	<	Vector.this.set(lastRet, e);
1109	<	expectedModCount = modCount;
1107	>	try {
1108	>	Vector.this.remove(i);
1109	>	if (i < cursor)
1110	>	cursor--;
1111	>	lastRet = -1;
1112	>	fence = Vector.this.size();
1113	>	expectedModCount = Vector.this.modCount;
1114		} catch (IndexOutOfBoundsException ex) {
1115		throw new ConcurrentModificationException();
1116		}
1117		}
1118
1119		public void add(E e) {
1120	<	if (expectedModCount != modCount)
1120	>	if (Vector.this.modCount != expectedModCount)
1121		throw new ConcurrentModificationException();
1122		try {
1123		int i = cursor;
1124	<	Vector.this.add(i, e);
1124	>	Vector.this.add(i, e);
1125		cursor = i + 1;
1126	<	lastRet = -1;
1127	<	expectedModCount = modCount;
1126	>	lastRet = -1;
1127	>	fence = Vector.this.size();
1128	>	expectedModCount = Vector.this.modCount;
1129		} catch (IndexOutOfBoundsException ex) {
1130		throw new ConcurrentModificationException();
1131		}
1132		}
1133		}
1134	+
1135	+	/**
1136	+	* Returns a view of the portion of this List between fromIndex,
1137	+	* inclusive, and toIndex, exclusive. (If fromIndex and toIndex are
1138	+	* equal, the returned List is empty.) The returned List is backed by this
1139	+	* List, so changes in the returned List are reflected in this List, and
1140	+	* vice-versa. The returned List supports all of the optional List
1141	+	* operations supported by this List.
1142	+	*
1143	+	* <p>This method eliminates the need for explicit range operations (of
1144	+	* the sort that commonly exist for arrays). Any operation that expects
1145	+	* a List can be used as a range operation by operating on a subList view
1146	+	* instead of a whole List. For example, the following idiom
1147	+	* removes a range of elements from a List:
1148	+	* <pre>
1149	+	* list.subList(from, to).clear();
1150	+	* </pre>
1151	+	* Similar idioms may be constructed for indexOf and lastIndexOf,
1152	+	* and all of the algorithms in the Collections class can be applied to
1153	+	* a subList.
1154	+	*
1155	+	* <p>The semantics of the List returned by this method become undefined if
1156	+	* the backing list (i.e., this List) is <i>structurally modified</i> in
1157	+	* any way other than via the returned List. (Structural modifications are
1158	+	* those that change the size of the List, or otherwise perturb it in such
1159	+	* a fashion that iterations in progress may yield incorrect results.)
1160	+	*
1161	+	* @param fromIndex low endpoint (inclusive) of the subList
1162	+	* @param toIndex high endpoint (exclusive) of the subList
1163	+	* @return a view of the specified range within this List
1164	+	* @throws IndexOutOfBoundsException if an endpoint index value is out of range
1165	+	* {@code (fromIndex < 0 \|\| toIndex > size)}
1166	+	* @throws IllegalArgumentException if the endpoint indices are out of order
1167	+	* {@code (fromIndex > toIndex)}
1168	+	*/
1169	+	public synchronized List<E> subList(int fromIndex, int toIndex) {
1170	+	return new VectorSubList(this, this, fromIndex, fromIndex, toIndex);
1171	+	}
1172	+
1173	+	/**
1174	+	* This class specializes the AbstractList version of SubList to
1175	+	* avoid the double-indirection penalty that would arise using a
1176	+	* synchronized wrapper, as well as to avoid some unnecessary
1177	+	* checks in sublist iterators.
1178	+	*/
1179	+	private static final class VectorSubList<E> extends AbstractList<E> implements RandomAccess {
1180	+	final Vector<E> base; // base list
1181	+	final AbstractList<E> parent; // Creating list
1182	+	final int baseOffset; // index wrt Vector
1183	+	final int parentOffset; // index wrt parent
1184	+	int length; // length of sublist
1185	+
1186	+	VectorSubList(Vector<E> base, AbstractList<E> parent, int baseOffset,
1187	+	int fromIndex, int toIndex) {
1188	+	if (fromIndex < 0)
1189	+	throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
1190	+	if (toIndex > parent.size())
1191	+	throw new IndexOutOfBoundsException("toIndex = " + toIndex);
1192	+	if (fromIndex > toIndex)
1193	+	throw new IllegalArgumentException("fromIndex(" + fromIndex +
1194	+	") > toIndex(" + toIndex + ")");
1195	+
1196	+	this.base = base;
1197	+	this.parent = parent;
1198	+	this.baseOffset = baseOffset;
1199	+	this.parentOffset = fromIndex;
1200	+	this.length = toIndex - fromIndex;
1201	+	modCount = base.modCount;
1202	+	}
1203	+
1204	+	/**
1205	+	* Returns an IndexOutOfBoundsException with nicer message
1206	+	*/
1207	+	private IndexOutOfBoundsException indexError(int index) {
1208	+	return new IndexOutOfBoundsException("Index: " + index +
1209	+	", Size: " + length);
1210	+	}
1211	+
1212	+	public E set(int index, E element) {
1213	+	synchronized(base) {
1214	+	if (index < 0 \|\| index >= length)
1215	+	throw indexError(index);
1216	+	if (base.modCount != modCount)
1217	+	throw new ConcurrentModificationException();
1218	+	return base.set(index + baseOffset, element);
1219	+	}
1220	+	}
1221	+
1222	+	public E get(int index) {
1223	+	synchronized(base) {
1224	+	if (index < 0 \|\| index >= length)
1225	+	throw indexError(index);
1226	+	if (base.modCount != modCount)
1227	+	throw new ConcurrentModificationException();
1228	+	return base.get(index + baseOffset);
1229	+	}
1230	+	}
1231	+
1232	+	public int size() {
1233	+	synchronized(base) {
1234	+	if (base.modCount != modCount)
1235	+	throw new ConcurrentModificationException();
1236	+	return length;
1237	+	}
1238	+	}
1239	+
1240	+	public void add(int index, E element) {
1241	+	synchronized(base) {
1242	+	if (index < 0 \|\| index > length)
1243	+	throw indexError(index);
1244	+	if (base.modCount != modCount)
1245	+	throw new ConcurrentModificationException();
1246	+	parent.add(index + parentOffset, element);
1247	+	length++;
1248	+	modCount = base.modCount;
1249	+	}
1250	+	}
1251	+
1252	+	public E remove(int index) {
1253	+	synchronized(base) {
1254	+	if (index < 0 \|\| index >= length)
1255	+	throw indexError(index);
1256	+	if (base.modCount != modCount)
1257	+	throw new ConcurrentModificationException();
1258	+	E result = parent.remove(index + parentOffset);
1259	+	length--;
1260	+	modCount = base.modCount;
1261	+	return result;
1262	+	}
1263	+	}
1264	+
1265	+	protected void removeRange(int fromIndex, int toIndex) {
1266	+	synchronized(base) {
1267	+	if (base.modCount != modCount)
1268	+	throw new ConcurrentModificationException();
1269	+	parent.removeRange(fromIndex + parentOffset,
1270	+	toIndex + parentOffset);
1271	+	length -= (toIndex-fromIndex);
1272	+	modCount = base.modCount;
1273	+	}
1274	+	}
1275	+
1276	+	public boolean addAll(Collection<? extends E> c) {
1277	+	return addAll(length, c);
1278	+	}
1279	+
1280	+	public boolean addAll(int index, Collection<? extends E> c) {
1281	+	synchronized(base) {
1282	+	if (index < 0 \|\| index > length)
1283	+	throw indexError(index);
1284	+	int cSize = c.size();
1285	+	if (cSize==0)
1286	+	return false;
1287	+
1288	+	if (base.modCount != modCount)
1289	+	throw new ConcurrentModificationException();
1290	+	parent.addAll(parentOffset + index, c);
1291	+	modCount = base.modCount;
1292	+	length += cSize;
1293	+	return true;
1294	+	}
1295	+	}
1296	+
1297	+	public boolean equals(Object o) {
1298	+	synchronized(base) {return super.equals(o);}
1299	+	}
1300	+
1301	+	public int hashCode() {
1302	+	synchronized(base) {return super.hashCode();}
1303	+	}
1304	+
1305	+	public int indexOf(Object o) {
1306	+	synchronized(base) {return super.indexOf(o);}
1307	+	}
1308	+
1309	+	public int lastIndexOf(Object o) {
1310	+	synchronized(base) {return super.lastIndexOf(o);}
1311	+	}
1312	+
1313	+	public List<E> subList(int fromIndex, int toIndex) {
1314	+	return new VectorSubList(base, this, fromIndex + baseOffset,
1315	+	fromIndex, toIndex);
1316	+	}
1317	+
1318	+	public Iterator<E> iterator() {
1319	+	synchronized(base) {
1320	+	return new VectorSubListIterator(this, 0);
1321	+	}
1322	+	}
1323	+
1324	+	public synchronized ListIterator<E> listIterator() {
1325	+	synchronized(base) {
1326	+	return new VectorSubListIterator(this, 0);
1327	+	}
1328	+	}
1329	+
1330	+	public ListIterator<E> listIterator(int index) {
1331	+	synchronized(base) {
1332	+	if (index < 0 \|\| index > length)
1333	+	throw indexError(index);
1334	+	return new VectorSubListIterator(this, index);
1335	+	}
1336	+	}
1337	+
1338	+	/**
1339	+	* Same idea as VectorIterator, except routing structural
1340	+	* change operations through the sublist.
1341	+	*/
1342	+	private static final class VectorSubListIterator<E> implements ListIterator<E> {
1343	+	final Vector<E> base; // base list
1344	+	final VectorSubList<E> outer; // Sublist creating this iteraor
1345	+	final int offset; // cursor offset wrt base
1346	+	int cursor; // Current index
1347	+	int fence; // Upper bound on cursor
1348	+	int lastRet; // Index of returned element, or -1
1349	+	int expectedModCount; // Expected modCount of base Vector
1350	+
1351	+	VectorSubListIterator(VectorSubList<E> list, int index) {
1352	+	this.lastRet = -1;
1353	+	this.cursor = index;
1354	+	this.outer = list;
1355	+	this.offset = list.baseOffset;
1356	+	this.fence = list.length;
1357	+	this.base = list.base;
1358	+	this.expectedModCount = base.modCount;
1359	+	}
1360	+
1361	+	public boolean hasNext() {
1362	+	return cursor < fence;
1363	+	}
1364	+
1365	+	public boolean hasPrevious() {
1366	+	return cursor > 0;
1367	+	}
1368	+
1369	+	public int nextIndex() {
1370	+	return cursor;
1371	+	}
1372	+
1373	+	public int previousIndex() {
1374	+	return cursor - 1;
1375	+	}
1376	+
1377	+	public E next() {
1378	+	int i = cursor;
1379	+	if (cursor >= fence)
1380	+	throw new NoSuchElementException();
1381	+	Object next = base.iteratorGet(i + offset, expectedModCount);
1382	+	lastRet = i;
1383	+	cursor = i + 1;
1384	+	return (E)next;
1385	+	}
1386	+
1387	+	public E previous() {
1388	+	int i = cursor - 1;
1389	+	if (i < 0)
1390	+	throw new NoSuchElementException();
1391	+	Object prev = base.iteratorGet(i + offset, expectedModCount);
1392	+	lastRet = i;
1393	+	cursor = i;
1394	+	return (E)prev;
1395	+	}
1396	+
1397	+	public void set(E e) {
1398	+	if (lastRet < 0)
1399	+	throw new IllegalStateException();
1400	+	if (base.modCount != expectedModCount)
1401	+	throw new ConcurrentModificationException();
1402	+	try {
1403	+	outer.set(lastRet, e);
1404	+	expectedModCount = base.modCount;
1405	+	} catch (IndexOutOfBoundsException ex) {
1406	+	throw new ConcurrentModificationException();
1407	+	}
1408	+	}
1409	+
1410	+	public void remove() {
1411	+	int i = lastRet;
1412	+	if (i < 0)
1413	+	throw new IllegalStateException();
1414	+	if (base.modCount != expectedModCount)
1415	+	throw new ConcurrentModificationException();
1416	+	try {
1417	+	outer.remove(i);
1418	+	if (i < cursor)
1419	+	cursor--;
1420	+	lastRet = -1;
1421	+	fence = outer.length;
1422	+	expectedModCount = base.modCount;
1423	+	} catch (IndexOutOfBoundsException ex) {
1424	+	throw new ConcurrentModificationException();
1425	+	}
1426	+	}
1427	+
1428	+	public void add(E e) {
1429	+	if (base.modCount != expectedModCount)
1430	+	throw new ConcurrentModificationException();
1431	+	try {
1432	+	int i = cursor;
1433	+	outer.add(i, e);
1434	+	cursor = i + 1;
1435	+	lastRet = -1;
1436	+	fence = outer.length;
1437	+	expectedModCount = base.modCount;
1438	+	} catch (IndexOutOfBoundsException ex) {
1439	+	throw new ConcurrentModificationException();
1440	+	}
1441	+	}
1442	+	}
1443	+	}
1444		}
1445	+
1446	+
1447	+

Diff Legend

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

Comparing jsr166/src/main/java/util/Vector.java (file contents): Revision 1.8 by jsr166, Tue Feb 7 20:54:24 2006 UTC vs. Revision 1.20 by jsr166, Sun Jan 7 07:38:27 2007 UTC

Diff Legend

Comparing jsr166/src/main/java/util/Vector.java (file contents):
Revision 1.8 by jsr166, Tue Feb 7 20:54:24 2006 UTC vs.
Revision 1.20 by jsr166, Sun Jan 7 07:38:27 2007 UTC