ViewVC Help

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

root/jsr166/jsr166/src/jsr166e/extra/ReadMostlyVector.java

Comparing jsr166/src/jsr166e/extra/ReadMostlyVector.java (file contents):
Revision 1.8 by jsr166, Mon Jul 18 15:24:08 2011 UTC vs.
Revision 1.20 by jsr166, Sat Dec 31 18:48:47 2011 UTC

#	Line 19 | Line 19 | import java.util.*;
19		* best-effort in the presence of concurrent modifications, and do
20		* <em>NOT</em> throw {@link ConcurrentModificationException}.  An
21		* iterator's {@code next()} method returns consecutive elements as
22	<	* they appear in the underlying array upon each access. Alternatvely,
22	>	* they appear in the underlying array upon each access. Alternatively,
23		* method {@link #snapshotIterator} may be used for deterministic
24		* traversals, at the expense of making a copy, and unavailability of
25		* method {@code Iterator.remove}.
#	Line 32 | Line 32 | import java.util.*;
32		*
33		* @author Doug Lea
34		*/
35	<	public class ReadMostlyVector<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
35	>	public class ReadMostlyVector<E>
36	>	implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
37		private static final long serialVersionUID = 8673264195747942595L;
38
39		/*
#	Line 57 | Line 58 | public class ReadMostlyVector<E> impleme
58		private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
59
60		// fields are non-private to simpify nested class access
61	<	Object[] array;
61	>	volatile Object[] array;
62		final SequenceLock lock;
63	<	int count;
63	>	volatile int count;
64		final int capacityIncrement;
65
66		/**
#	Line 129 | Line 130 | public class ReadMostlyVector<E> impleme
130		}
131
132		// For explanation, see CopyOnWriteArrayList
133	<	final void grow(int minCapacity) {
133	>	final Object[] grow(int minCapacity) {
134		int oldCapacity = array.length;
135		int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
136		capacityIncrement : oldCapacity);
#	Line 137 | Line 138 | public class ReadMostlyVector<E> impleme
138		newCapacity = minCapacity;
139		if (newCapacity - MAX_ARRAY_SIZE > 0)
140		newCapacity = hugeCapacity(minCapacity);
141	<	array = Arrays.copyOf(array, newCapacity);
141	>	return array = Arrays.copyOf(array, newCapacity);
142		}
143
144		static int hugeCapacity(int minCapacity) {
#	Line 199 | Line 200 | public class ReadMostlyVector<E> impleme
200		return -1;
201		}
202
203	<	final void rawAdd(Object e) {
203	>	final void rawAdd(E e) {
204		int n = count;
205	<	if (n >= array.length)
206	<	grow(n + 1);
207	<	array[n] = e;
205	>	Object[] items = array;
206	>	if (n >= items.length)
207	>	items = grow(n + 1);
208	>	items[n] = e;
209		count = n + 1;
210		}
211
212	<	final void rawAddAt(int index, Object e) {
212	>	final void rawAddAt(int index, E e) {
213		int n = count;
214	+	Object[] items = array;
215		if (index > n)
216		throw new ArrayIndexOutOfBoundsException(index);
217	<	if (n >= array.length)
218	<	grow(n + 1);
217	>	if (n >= items.length)
218	>	items = grow(n + 1);
219		if (index < n)
220	<	System.arraycopy(array, index, array, index + 1, n - index);
221	<	array[index] = e;
220	>	System.arraycopy(items, index, items, index + 1, n - index);
221	>	items[index] = e;
222		count = n + 1;
223		}
224
225		final boolean rawAddAllAt(int index, Object[] elements) {
226		int n = count;
227	+	Object[] items = array;
228		if (index < 0 || index > n)
229		throw new ArrayIndexOutOfBoundsException(index);
230		int len = elements.length;
231		if (len == 0)
232		return false;
233		int newCount = n + len;
234	<	if (newCount >= array.length)
235	<	grow(newCount);
236	<	int mv = count - index;
234	>	if (newCount >= items.length)
235	>	items = grow(newCount);
236	>	int mv = n - index;
237		if (mv > 0)
238	<	System.arraycopy(array, index, array, index + len, mv);
239	<	System.arraycopy(elements, 0, array, index, len);
238	>	System.arraycopy(items, index, items, index + len, mv);
239	>	System.arraycopy(elements, 0, items, index, len);
240		count = newCount;
241		return true;
242		}
243
244		final boolean rawRemoveAt(int index) {
245		int n = count - 1;
246	+	Object[] items = array;
247		if (index < 0 || index > n)
248		return false;
249		int mv = n - index;
250		if (mv > 0)
251	<	System.arraycopy(array, index + 1, array, index, mv);
252	<	array[n] = null;
251	>	System.arraycopy(items, index + 1, items, index, mv);
252	>	items[n] = null;
253		count = n;
254		return true;
255		}
#	Line 257 | Line 262 | public class ReadMostlyVector<E> impleme
262		* field under lock.
263		*/
264		final boolean internalRemoveAll(Collection<?> c, int origin, int bound) {
265	<	SequenceLock lock = this.lock;
265	>	final SequenceLock lock = this.lock;
266		boolean removed = false;
267		lock.lock();
268		try {
#	Line 276 | Line 281 | public class ReadMostlyVector<E> impleme
281		}
282
283		final boolean internalRetainAll(Collection<?> c, int origin, int bound) {
284	<	SequenceLock lock = this.lock;
284	>	final SequenceLock lock = this.lock;
285		boolean removed = false;
286		if (c != this) {
287		lock.lock();
288		try {
289	+	Object[] items = array;
290		int i = origin;
291		int n = count;
292		int fence = bound < 0 || bound > n ? n : bound;
293		while (i >= 0 && i < fence) {
294	<	if (c.contains(array[i]))
294	>	if (c.contains(items[i]))
295		++i;
296		else {
297		--fence;
298	<	int mv = --count - i;
298	>	int mv = --n - i;
299		if (mv > 0)
300	<	System.arraycopy(array, i + 1, array, i, mv);
295	<	removed = true;
300	>	System.arraycopy(items, i + 1, items, i, mv);
301		}
302		}
303	+	if (count != n) {
304	+	count = n;
305	+	removed = true;
306	+	}
307		} finally {
308		lock.unlock();
309		}
#	Line 306 | Line 315 | public class ReadMostlyVector<E> impleme
315		int n = count;
316		int fence = bound < 0 || bound > n ? n : bound;
317		if (origin >= 0 && origin < fence) {
318	+	Object[] items = array;
319		int removed = fence - origin;
320		int newCount = n - removed;
321		int mv = n - (origin + removed);
322		if (mv > 0)
323	<	System.arraycopy(array, origin + removed, array, origin, mv);
323	>	System.arraycopy(items, origin + removed, items, origin, mv);
324		for (int i = n; i < newCount; ++i)
325	<	array[i] = null;
325	>	items[i] = null;
326		count = newCount;
327		}
328		}
329
330		final boolean internalContainsAll(Collection<?> c, int origin, int bound) {
331	<	SequenceLock lock = this.lock;
331	>	final SequenceLock lock = this.lock;
332		boolean contained;
333		boolean locked = false;
334		try {
335		for (;;) {
336		long seq = lock.awaitAvailability();
337	+	int n = count;
338		Object[] items = array;
339		int len = items.length;
329	–	int n = count;
340		if (n > len)
341		continue;
342		int fence = bound < 0 || bound > n ? n : bound;
#	Line 358 | Line 368 | public class ReadMostlyVector<E> impleme
368		}
369
370		final boolean internalEquals(List<?> list, int origin, int bound) {
371	<	SequenceLock lock = this.lock;
371	>	final SequenceLock lock = this.lock;
372		boolean locked = false;
373		boolean equal;
374		try {
#	Line 399 | Line 409 | public class ReadMostlyVector<E> impleme
409		}
410
411		final int internalHashCode(int origin, int bound) {
412	<	SequenceLock lock = this.lock;
412	>	final SequenceLock lock = this.lock;
413		int hash;
414		boolean locked = false;
415		try {
#	Line 407 | Line 417 | public class ReadMostlyVector<E> impleme
417		hash = 1;
418		long seq = lock.awaitAvailability();
419		Object[] items = array;
410	–	int len = items.length;
420		int n = count;
421	+	int len = items.length;
422		if (n > len)
423		continue;
424		int fence = bound < 0 || bound > n ? n : bound;
#	Line 431 | Line 441 | public class ReadMostlyVector<E> impleme
441		}
442
443		final String internalToString(int origin, int bound) {
444	<	SequenceLock lock = this.lock;
444	>	final SequenceLock lock = this.lock;
445		String ret;
446		boolean locked = false;
447		try {
448		outer:for (;;) {
449		long seq = lock.awaitAvailability();
450		Object[] items = array;
441	–	int len = items.length;
451		int n = count;
452	+	int len = items.length;
453		if (n > len)
454		continue;
455		int fence = bound < 0 || bound > n ? n : bound;
#	Line 478 | Line 488 | public class ReadMostlyVector<E> impleme
488
489		final Object[] internalToArray(int origin, int bound) {
490		Object[] result;
491	<	SequenceLock lock = this.lock;
491	>	final SequenceLock lock = this.lock;
492		boolean locked = false;
493		try {
494		for (;;) {
495		result = null;
496		long seq = lock.awaitAvailability();
497		Object[] items = array;
488	–	int len = items.length;
498		int n = count;
499	+	int len = items.length;
500		if (n > len)
501		continue;
502		int fence = bound < 0 || bound > n ? n : bound;
#	Line 505 | Line 515 | public class ReadMostlyVector<E> impleme
515		return result;
516		}
517
518	+	@SuppressWarnings("unchecked")
519		final <T> T[] internalToArray(T[] a, int origin, int bound) {
520		int alen = a.length;
521		T[] result;
522	<	SequenceLock lock = this.lock;
522	>	final SequenceLock lock = this.lock;
523		boolean locked = false;
524		try {
525		for (;;) {
526		long seq = lock.awaitAvailability();
527		Object[] items = array;
517	–	int len = items.length;
528		int n = count;
529	+	int len = items.length;
530		if (n > len)
531		continue;
532		int fence = bound < 0 || bound > n ? n : bound;
#	Line 524 | Line 535 | public class ReadMostlyVector<E> impleme
535		rlen = 0;
536		if (origin < 0 || alen >= rlen) {
537		if (rlen > 0)
538	<	System.arraycopy(array, 0, a, origin, rlen);
538	>	System.arraycopy(items, 0, a, origin, rlen);
539		if (alen > rlen)
540		a[rlen] = null;
541		result = a;
542		}
543		else
544	<	result = (T[]) Arrays.copyOfRange(array, origin,
544	>	result = (T[]) Arrays.copyOfRange(items, origin,
545		fence, a.getClass());
546		if (lock.getSequence() == seq)
547		break;
#	Line 547 | Line 558 | public class ReadMostlyVector<E> impleme
558		// public List methods
559
560		public boolean add(E e) {
561	<	SequenceLock lock = this.lock;
561	>	final SequenceLock lock = this.lock;
562		lock.lock();
563		try {
564		rawAdd(e);
#	Line 558 | Line 569 | public class ReadMostlyVector<E> impleme
569		}
570
571		public void add(int index, E element) {
572	<	SequenceLock lock = this.lock;
572	>	final SequenceLock lock = this.lock;
573		lock.lock();
574		try {
575		rawAddAt(index, element);
#	Line 572 | Line 583 | public class ReadMostlyVector<E> impleme
583		int len = elements.length;
584		if (len == 0)
585		return false;
586	<	SequenceLock lock = this.lock;
586	>	final SequenceLock lock = this.lock;
587		lock.lock();
588		try {
589	<	int newCount = count + len;
590	<	if (newCount >= array.length)
591	<	grow(newCount);
592	<	System.arraycopy(elements, 0, array, count, len);
589	>	Object[] items = array;
590	>	int n = count;
591	>	int newCount = n + len;
592	>	if (newCount >= items.length)
593	>	items = grow(newCount);
594	>	System.arraycopy(elements, 0, items, n, len);
595		count = newCount;
596		} finally {
597		lock.unlock();
#	Line 587 | Line 600 | public class ReadMostlyVector<E> impleme
600		}
601
602		public boolean addAll(int index, Collection<? extends E> c) {
603	<	SequenceLock lock = this.lock;
603	>	final SequenceLock lock = this.lock;
604		boolean ret;
605		Object[] elements = c.toArray();
606		lock.lock();
#	Line 600 | Line 613 | public class ReadMostlyVector<E> impleme
613		}
614
615		public void clear() {
616	<	SequenceLock lock = this.lock;
616	>	final SequenceLock lock = this.lock;
617		lock.lock();
618		try {
619	<	for (int i = 0; i < count; i++)
620	<	array[i] = null;
619	>	int n = count;
620	>	Object[] items = array;
621	>	for (int i = 0; i < n; i++)
622	>	items[i] = null;
623		count = 0;
624		} finally {
625		lock.unlock();
#	Line 628 | Line 643 | public class ReadMostlyVector<E> impleme
643		}
644
645		public E get(int index) {
646	<	SequenceLock lock = this.lock;
646	>	final SequenceLock lock = this.lock;
647		for (;;) {
648		long seq = lock.awaitAvailability();
634	–	Object[] items = array;
649		int n = count;
650	<	if (n > items.length)
651	<	continue;
652	<	Object e; boolean ex;
639	<	if (index < 0 || index >= n) {
640	<	e = null;
641	<	ex = true;
642	<	}
643	<	else {
644	<	e = items[index];
645	<	ex = false;
646	<	}
650	>	Object[] items = array;
651	>	@SuppressWarnings("unchecked")
652	>	E e = (index < items.length) ? (E) items[index] : null;
653		if (lock.getSequence() == seq) {
654	<	if (ex)
654	>	if (index >= n)
655		throw new ArrayIndexOutOfBoundsException(index);
656	<	else
651	<	return (E)e;
656	>	return e;
657		}
658		}
659		}
#	Line 658 | Line 663 | public class ReadMostlyVector<E> impleme
663		}
664
665		public int indexOf(Object o) {
666	<	SequenceLock lock = this.lock;
662	<	for (;;) {
663	<	long seq = lock.awaitAvailability();
664	<	Object[] items = array;
665	<	int n = count;
666	<	if (n <= items.length) {
667	<	for (int i = 0; i < n; ++i) {
668	<	Object e = items[i];
669	<	if (lock.getSequence() != seq) {
670	<	lock.lock();
671	<	try {
672	<	return rawIndexOf(o, 0, count);
673	<	} finally {
674	<	lock.unlock();
675	<	}
676	<	}
677	<	else if ((o == null) ? e == null : o.equals(e))
678	<	return i;
679	<	}
680	<	return -1;
681	<	}
682	<	}
666	>	return indexOf(o, 0);
667		}
668
669		public boolean isEmpty() {
686	–	long ignore = lock.getSequence();
670		return count == 0;
671		}
672
673		public Iterator<E> iterator() {
674	<	return new Itr(this, 0);
674	>	return new Itr<E>(this, 0);
675		}
676
677		public int lastIndexOf(Object o) {
678	<	SequenceLock lock = this.lock;
678	>	final SequenceLock lock = this.lock;
679		for (;;) {
680		long seq = lock.awaitAvailability();
681		Object[] items = array;
#	Line 703 | Line 686 | public class ReadMostlyVector<E> impleme
686		if (lock.getSequence() != seq) {
687		lock.lock();
688		try {
689	<	return rawLastIndexOf(o, 0, count);
689	>	return rawLastIndexOf(o, count, 0);
690		} finally {
691		lock.unlock();
692		}
#	Line 717 | Line 700 | public class ReadMostlyVector<E> impleme
700		}
701
702		public ListIterator<E> listIterator() {
703	<	return new Itr(this, 0);
703	>	return new Itr<E>(this, 0);
704		}
705
706		public ListIterator<E> listIterator(int index) {
707	<	return new Itr(this, index);
707	>	return new Itr<E>(this, index);
708		}
709
710		public E remove(int index) {
711	<	SequenceLock lock = this.lock;
729	<	Object oldValue;
711	>	final SequenceLock lock = this.lock;
712		lock.lock();
713		try {
714		if (index < 0 || index >= count)
715		throw new ArrayIndexOutOfBoundsException(index);
716	<	oldValue = array[index];
716	>	@SuppressWarnings("unchecked")
717	>	E oldValue = (E) array[index];
718		rawRemoveAt(index);
719	+	return oldValue;
720		} finally {
721		lock.unlock();
722		}
739	–	return (E)oldValue;
723		}
724
725		public boolean remove(Object o) {
726	<	SequenceLock lock = this.lock;
744	<	boolean removed;
726	>	final SequenceLock lock = this.lock;
727		lock.lock();
728		try {
729	<	removed = rawRemoveAt(rawIndexOf(o, 0, count));
729	>	return rawRemoveAt(rawIndexOf(o, 0, count));
730		} finally {
731		lock.unlock();
732		}
751	–	return removed;
733		}
734
735		public boolean removeAll(Collection<?> c) {
#	Line 760 | Line 741 | public class ReadMostlyVector<E> impleme
741		}
742
743		public E set(int index, E element) {
744	<	Object oldValue;
764	<	SequenceLock lock = this.lock;
744	>	final SequenceLock lock = this.lock;
745		lock.lock();
746		try {
747	+	Object[] items = array;
748		if (index < 0 || index >= count)
749		throw new ArrayIndexOutOfBoundsException(index);
750	<	oldValue = array[index];
751	<	array[index] = element;
750	>	@SuppressWarnings("unchecked")
751	>	E oldValue = (E) items[index];
752	>	items[index] = element;
753	>	return oldValue;
754		} finally {
755		lock.unlock();
756		}
774	–	return (E)oldValue;
757		}
758
759		public int size() {
778	–	long ignore = lock.getSequence();
760		return count;
761		}
762
#	Line 784 | Line 765 | public class ReadMostlyVector<E> impleme
765		int ssize = toIndex - fromIndex;
766		if (fromIndex < 0 || toIndex > c || ssize < 0)
767		throw new IndexOutOfBoundsException();
768	<	return new ReadMostlyVectorSublist(this, fromIndex, ssize);
768	>	return new ReadMostlyVectorSublist<E>(this, fromIndex, ssize);
769		}
770
771		public Object[] toArray() {
#	Line 805 | Line 786 | public class ReadMostlyVector<E> impleme
786		* Append the element if not present.
787		*
788		* @param e element to be added to this list, if absent
789	<	* @return <tt>true</tt> if the element was added
789	>	* @return {@code true} if the element was added
790		*/
791		public boolean addIfAbsent(E e) {
792	<	boolean added;
812	<	SequenceLock lock = this.lock;
792	>	final SequenceLock lock = this.lock;
793		lock.lock();
794		try {
795		if (rawIndexOf(e, 0, count) < 0) {
796		rawAdd(e);
797	<	added = true;
797	>	return true;
798		}
799		else
800	<	added = false;
800	>	return false;
801		} finally {
802		lock.unlock();
803		}
824	–	return added;
804		}
805
806		/**
#	Line 843 | Line 822 | public class ReadMostlyVector<E> impleme
822		lock.lock();
823		try {
824		for (int i = 0; i < clen; ++i) {
825	<	Object e = cs[i];
825	>	@SuppressWarnings("unchecked")
826	>	E e = (E) cs[i];
827		if (rawIndexOf(e, 0, count) < 0) {
828		rawAdd(e);
829		++added;
#	Line 860 | Line 840 | public class ReadMostlyVector<E> impleme
840		* Returns an iterator operating over a snapshot copy of the
841		* elements of this collection created upon construction of the
842		* iterator. The iterator does <em>NOT</em> support the
843	<	* <tt>remove</tt> method.
843	>	* {@code remove} method.
844		*
845		* @return an iterator over the elements in this list in proper sequence
846		*/
#	Line 869 | Line 849 | public class ReadMostlyVector<E> impleme
849		}
850
851		static final class SnapshotIterator<E> implements Iterator<E> {
852	<	final Object[] items;
853	<	int cursor;
852	>	private final Object[] items;
853	>	private int cursor;
854		SnapshotIterator(ReadMostlyVector<E> v) { items = v.toArray(); }
855		public boolean hasNext() { return cursor < items.length; }
856	+	@SuppressWarnings("unchecked")
857		public E next() {
858		if (cursor < items.length)
859		return (E) items[cursor++];
#	Line 885 | Line 866 | public class ReadMostlyVector<E> impleme
866
867		/** See {@link Vector#firstElement} */
868		public E firstElement() {
869	<	SequenceLock lock = this.lock;
869	>	final SequenceLock lock = this.lock;
870		for (;;) {
871		long seq = lock.awaitAvailability();
872		Object[] items = array;
892	–	int len = items.length;
873		int n = count;
874	<	if (n > len)
875	<	continue;
896	<	Object e; boolean ex;
897	<	if (n > 0) {
898	<	e = items[0];
899	<	ex = false;
900	<	}
901	<	else {
902	<	e = null;
903	<	ex = true;
904	<	}
874	>	@SuppressWarnings("unchecked")
875	>	E e = (items.length > 0) ? (E) items[0] : null;
876		if (lock.getSequence() == seq) {
877	<	if (ex)
877	>	if (n <= 0)
878		throw new NoSuchElementException();
879	<	else
909	<	return (E)e;
879	>	return e;
880		}
881		}
882		}
883
884		/** See {@link Vector#lastElement} */
885		public E lastElement() {
886	<	SequenceLock lock = this.lock;
886	>	final SequenceLock lock = this.lock;
887		for (;;) {
888		long seq = lock.awaitAvailability();
889		Object[] items = array;
920	–	int len = items.length;
890		int n = count;
891	<	if (n > len)
892	<	continue;
924	<	Object e; boolean ex;
925	<	if (n > 0) {
926	<	e = items[n - 1];
927	<	ex = false;
928	<	}
929	<	else {
930	<	e = null;
931	<	ex = true;
932	<	}
891	>	@SuppressWarnings("unchecked")
892	>	E e = (n > 0 && items.length >= n) ? (E) items[n - 1] : null;
893		if (lock.getSequence() == seq) {
894	<	if (ex)
894	>	if (n <= 0)
895		throw new NoSuchElementException();
896	<	else
937	<	return (E)e;
896	>	return e;
897		}
898		}
899		}
900
901		/** See {@link Vector#indexOf(Object, int)} */
902		public int indexOf(Object o, int index) {
903	<	SequenceLock lock = this.lock;
903	>	final SequenceLock lock = this.lock;
904		int idx = 0;
905		boolean ex = false;
906		long seq = lock.awaitAvailability();
#	Line 960 | Line 919 | public class ReadMostlyVector<E> impleme
919		if (index < 0)
920		ex = true;
921		else
922	<	idx = rawIndexOf(o, 0, count);
922	>	idx = rawIndexOf(o, index, count);
923		} finally {
924		lock.unlock();
925		}
#	Line 972 | Line 931 | public class ReadMostlyVector<E> impleme
931
932		/** See {@link Vector#lastIndexOf(Object, int)} */
933		public int lastIndexOf(Object o, int index) {
934	<	SequenceLock lock = this.lock;
934	>	final SequenceLock lock = this.lock;
935		int idx = 0;
936		boolean ex = false;
937		long seq = lock.awaitAvailability();
#	Line 1005 | Line 964 | public class ReadMostlyVector<E> impleme
964		public void setSize(int newSize) {
965		if (newSize < 0)
966		throw new ArrayIndexOutOfBoundsException(newSize);
967	<	SequenceLock lock = this.lock;
967	>	final SequenceLock lock = this.lock;
968		lock.lock();
969		try {
970		int n = count;
971		if (newSize > n)
972		grow(newSize);
973		else {
974	+	Object[] items = array;
975		for (int i = newSize ; i < n ; i++)
976	<	array[i] = null;
976	>	items[i] = null;
977		}
978		count = newSize;
979		} finally {
#	Line 1023 | Line 983 | public class ReadMostlyVector<E> impleme
983
984		/** See {@link Vector#copyInto} */
985		public void copyInto(Object[] anArray) {
986	<	SequenceLock lock = this.lock;
986	>	final SequenceLock lock = this.lock;
987		lock.lock();
988		try {
989		System.arraycopy(array, 0, anArray, 0, count);
#	Line 1034 | Line 994 | public class ReadMostlyVector<E> impleme
994
995		/** See {@link Vector#trimToSize} */
996		public void trimToSize() {
997	<	SequenceLock lock = this.lock;
997	>	final SequenceLock lock = this.lock;
998		lock.lock();
999		try {
1000	<	if (count < array.length)
1001	<	array = Arrays.copyOf(array, count);
1000	>	Object[] items = array;
1001	>	int n = count;
1002	>	if (n < items.length)
1003	>	array = Arrays.copyOf(items, n);
1004		} finally {
1005		lock.unlock();
1006		}
#	Line 1047 | Line 1009 | public class ReadMostlyVector<E> impleme
1009		/** See {@link Vector#ensureCapacity} */
1010		public void ensureCapacity(int minCapacity) {
1011		if (minCapacity > 0) {
1012	<	SequenceLock lock = this.lock;
1012	>	final SequenceLock lock = this.lock;
1013		lock.lock();
1014		try {
1015		if (minCapacity - array.length > 0)
#	Line 1060 | Line 1022 | public class ReadMostlyVector<E> impleme
1022
1023		/** See {@link Vector#elements} */
1024		public Enumeration<E> elements() {
1025	<	return new Itr(this, 0);
1025	>	return new Itr<E>(this, 0);
1026		}
1027
1028		/** See {@link Vector#capacity} */
1029		public int capacity() {
1068	–	long ignore = lock.getSequence();
1030		return array.length;
1031		}
1032
#	Line 1106 | Line 1067 | public class ReadMostlyVector<E> impleme
1067
1068		// other methods
1069
1070	<	public Object clone() {
1071	<	SequenceLock lock = this.lock;
1070	>	public ReadMostlyVector<E> clone() {
1071	>	final SequenceLock lock = this.lock;
1072		Object[] a = null;
1073		boolean retry = false;
1074		long seq = lock.awaitAvailability();
#	Line 1126 | Line 1087 | public class ReadMostlyVector<E> impleme
1087		lock.unlock();
1088		}
1089		}
1090	<	return new ReadMostlyVector(a, n, capacityIncrement);
1090	>	return new ReadMostlyVector<E>(a, n, capacityIncrement);
1091		}
1092
1093		private void writeObject(java.io.ObjectOutputStream s)
1094		throws java.io.IOException {
1095	<	SequenceLock lock = this.lock;
1095	>	final SequenceLock lock = this.lock;
1096		lock.lock();
1097		try {
1098		s.defaultWriteObject();
#	Line 1140 | Line 1101 | public class ReadMostlyVector<E> impleme
1101		}
1102		}
1103
1104	<	static final class Itr<E> implements ListIterator<E>, Enumeration<E>  {
1104	>	static final class Itr<E> implements ListIterator<E>, Enumeration<E> {
1105		final ReadMostlyVector<E> list;
1106		final SequenceLock lock;
1107		Object[] items;
1108	<	Object next, prev;
1108	>	E next, prev;
1109		long seq;
1110		int cursor;
1111		int fence;
#	Line 1170 | Line 1131 | public class ReadMostlyVector<E> impleme
1131		lock.getSequence() != seq);
1132		}
1133
1134	+	@SuppressWarnings("unchecked")
1135		public boolean hasNext() {
1136		boolean valid;
1137		int i = cursor;
#	Line 1178 | Line 1140 | public class ReadMostlyVector<E> impleme
1140		valid = false;
1141		break;
1142		}
1143	<	next = items[i];
1143	>	next = (E) items[i];
1144		if (lock.getSequence() == seq) {
1145		valid = true;
1146		break;
#	Line 1188 | Line 1150 | public class ReadMostlyVector<E> impleme
1150		return validNext = valid;
1151		}
1152
1153	+	@SuppressWarnings("unchecked")
1154		public boolean hasPrevious() {
1155		boolean valid;
1156		int i = cursor - 1;
#	Line 1196 | Line 1159 | public class ReadMostlyVector<E> impleme
1159		valid = false;
1160		break;
1161		}
1162	<	prev = items[i];
1162	>	prev = (E) items[i];
1163		if (lock.getSequence() == seq) {
1164		valid = true;
1165		break;
#	Line 1210 | Line 1173 | public class ReadMostlyVector<E> impleme
1173		if (validNext || hasNext()) {
1174		validNext = false;
1175		lastRet = cursor++;
1176	<	return (E) next;
1176	>	return next;
1177		}
1178		throw new NoSuchElementException();
1179		}
#	Line 1219 | Line 1182 | public class ReadMostlyVector<E> impleme
1182		if (validPrev || hasPrevious()) {
1183		validPrev = false;
1184		lastRet = cursor--;
1185	<	return (E) prev;
1185	>	return prev;
1186		}
1187		throw new NoSuchElementException();
1188		}
#	Line 1276 | Line 1239 | public class ReadMostlyVector<E> impleme
1239		public int previousIndex() { return cursor - 1; }
1240		}
1241
1242	<	static final class ReadMostlyVectorSublist<E> implements List<E>, RandomAccess, java.io.Serializable {
1242	>	static final class ReadMostlyVectorSublist<E>
1243	>	implements List<E>, RandomAccess, java.io.Serializable {
1244	>	static final long serialVersionUID = 3041673470172026059L;
1245	>
1246		final ReadMostlyVector<E> list;
1247		final int offset;
1248		volatile int size;
1249
1250	<	ReadMostlyVectorSublist(ReadMostlyVector<E> list, int offset, int size) {
1250	>	ReadMostlyVectorSublist(ReadMostlyVector<E> list,
1251	>	int offset, int size) {
1252		this.list = list;
1253		this.offset = offset;
1254		this.size = size;
#	Line 1293 | Line 1260 | public class ReadMostlyVector<E> impleme
1260		}
1261
1262		public boolean add(E element) {
1263	<	SequenceLock lock = list.lock;
1263	>	final SequenceLock lock = list.lock;
1264		lock.lock();
1265		try {
1266		int c = size;
#	Line 1306 | Line 1273 | public class ReadMostlyVector<E> impleme
1273		}
1274
1275		public void add(int index, E element) {
1276	<	SequenceLock lock = list.lock;
1276	>	final SequenceLock lock = list.lock;
1277		lock.lock();
1278		try {
1279		if (index < 0 || index > size)
#	Line 1320 | Line 1287 | public class ReadMostlyVector<E> impleme
1287
1288		public boolean addAll(Collection<? extends E> c) {
1289		Object[] elements = c.toArray();
1290	<	int added;
1324	<	SequenceLock lock = list.lock;
1290	>	final SequenceLock lock = list.lock;
1291		lock.lock();
1292		try {
1293		int s = size;
1294		int pc = list.count;
1295		list.rawAddAllAt(offset + s, elements);
1296	<	added = list.count - pc;
1296	>	int added = list.count - pc;
1297		size = s + added;
1298	+	return added != 0;
1299		} finally {
1300		lock.unlock();
1301		}
1335	–	return added != 0;
1302		}
1303
1304		public boolean addAll(int index, Collection<? extends E> c) {
1305		Object[] elements = c.toArray();
1306	<	int added;
1341	<	SequenceLock lock = list.lock;
1306	>	final SequenceLock lock = list.lock;
1307		lock.lock();
1308		try {
1309		int s = size;
#	Line 1346 | Line 1311 | public class ReadMostlyVector<E> impleme
1311		throw new ArrayIndexOutOfBoundsException(index);
1312		int pc = list.count;
1313		list.rawAddAllAt(index + offset, elements);
1314	<	added = list.count - pc;
1314	>	int added = list.count - pc;
1315		size = s + added;
1316	+	return added != 0;
1317		} finally {
1318		lock.unlock();
1319		}
1354	–	return added != 0;
1320		}
1321
1322		public void clear() {
1323	<	SequenceLock lock = list.lock;
1323	>	final SequenceLock lock = list.lock;
1324		lock.lock();
1325		try {
1326		list.internalClear(offset, offset + size);
#	Line 1392 | Line 1357 | public class ReadMostlyVector<E> impleme
1357		}
1358
1359		public int indexOf(Object o) {
1360	<	SequenceLock lock = list.lock;
1360	>	final SequenceLock lock = list.lock;
1361		long seq = lock.awaitAvailability();
1362		Object[] items = list.array;
1363		int c = list.count;
#	Line 1416 | Line 1381 | public class ReadMostlyVector<E> impleme
1381		}
1382
1383		public Iterator<E> iterator() {
1384	<	return new SubItr(this, offset);
1384	>	return new SubItr<E>(this, offset);
1385		}
1386
1387		public int lastIndexOf(Object o) {
1388	<	SequenceLock lock = list.lock;
1388	>	final SequenceLock lock = list.lock;
1389		long seq = lock.awaitAvailability();
1390		Object[] items = list.array;
1391		int c = list.count;
#	Line 1440 | Line 1405 | public class ReadMostlyVector<E> impleme
1405		}
1406
1407		public ListIterator<E> listIterator() {
1408	<	return new SubItr(this, offset);
1408	>	return new SubItr<E>(this, offset);
1409		}
1410
1411		public ListIterator<E> listIterator(int index) {
1412	<	return new SubItr(this, index + offset);
1412	>	return new SubItr<E>(this, index + offset);
1413		}
1414
1415		public E remove(int index) {
1416	<	Object result;
1452	<	SequenceLock lock = list.lock;
1416	>	final SequenceLock lock = list.lock;
1417		lock.lock();
1418		try {
1419		Object[] items = list.array;
1420		int i = index + offset;
1421		if (index < 0 || index >= size || i >= items.length)
1422		throw new ArrayIndexOutOfBoundsException(index);
1423	<	result = items[i];
1423	>	@SuppressWarnings("unchecked")
1424	>	E result = (E) items[i];
1425		list.rawRemoveAt(i);
1426		size--;
1427	+	return result;
1428		} finally {
1429		lock.unlock();
1430		}
1465	–	return (E)result;
1431		}
1432
1433		public boolean remove(Object o) {
1434	<	boolean removed = false;
1470	<	SequenceLock lock = list.lock;
1434	>	final SequenceLock lock = list.lock;
1435		lock.lock();
1436		try {
1437		if (list.rawRemoveAt(list.rawIndexOf(o, offset,
1438		offset + size))) {
1475	–	removed = true;
1439		--size;
1440	+	return true;
1441		}
1442	+	else
1443	+	return false;
1444		} finally {
1445		lock.unlock();
1446		}
1481	–	return removed;
1447		}
1448
1449		public boolean removeAll(Collection<?> c) {
#	Line 1504 | Line 1469 | public class ReadMostlyVector<E> impleme
1469		int ssize = toIndex - fromIndex;
1470		if (fromIndex < 0 || toIndex > c || ssize < 0)
1471		throw new IndexOutOfBoundsException();
1472	<	return new ReadMostlyVectorSublist(list, offset+fromIndex, ssize);
1472	>	return new ReadMostlyVectorSublist<E>(list, offset+fromIndex, ssize);
1473		}
1474
1475		public Object[] toArray() {
#	Line 1526 | Line 1491 | public class ReadMostlyVector<E> impleme
1491		final ReadMostlyVector<E> list;
1492		final SequenceLock lock;
1493		Object[] items;
1494	<	Object next, prev;
1494	>	E next, prev;
1495		long seq;
1496		int cursor;
1497		int fence;
#	Line 1557 | Line 1522 | public class ReadMostlyVector<E> impleme
1522		} while (lock.getSequence() != seq);
1523		}
1524
1525	+	@SuppressWarnings("unchecked")
1526		public boolean hasNext() {
1527		boolean valid;
1528		int i = cursor;
#	Line 1565 | Line 1531 | public class ReadMostlyVector<E> impleme
1531		valid = false;
1532		break;
1533		}
1534	<	next = items[i];
1534	>	next = (E) items[i];
1535		if (lock.getSequence() == seq) {
1536		valid = true;
1537		break;
#	Line 1575 | Line 1541 | public class ReadMostlyVector<E> impleme
1541		return validNext = valid;
1542		}
1543
1544	+	@SuppressWarnings("unchecked")
1545		public boolean hasPrevious() {
1546		boolean valid;
1547		int i = cursor - 1;
#	Line 1583 | Line 1550 | public class ReadMostlyVector<E> impleme
1550		valid = false;
1551		break;
1552		}
1553	<	prev = items[i];
1553	>	prev = (E) items[i];
1554		if (lock.getSequence() == seq) {
1555		valid = true;
1556		break;
#	Line 1597 | Line 1564 | public class ReadMostlyVector<E> impleme
1564		if (validNext || hasNext()) {
1565		validNext = false;
1566		lastRet = cursor++;
1567	<	return (E) next;
1567	>	return next;
1568		}
1569		throw new NoSuchElementException();
1570		}
#	Line 1606 | Line 1573 | public class ReadMostlyVector<E> impleme
1573		if (validPrev || hasPrevious()) {
1574		validPrev = false;
1575		lastRet = cursor--;
1576	<	return (E) prev;
1576	>	return prev;
1577		}
1578		throw new NoSuchElementException();
1579		}

Diff Legend

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