test/loops/RWCollection.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

/**
 * This is an incomplete implementation of a wrapper class
 * that places read-write locks around unsynchronized Collections.
 * Exists as a sample input for CollectionLoops test.
 */
public final class RWCollection<E> implements Collection<E> {
    private final Collection c;
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public RWCollection(Collection<E> c) {
        if (c == null)
            throw new NullPointerException();
        this.c = c;
    }

    public RWCollection() {
        this(new ArrayList<E>());
    }

    public final int size() {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.size(); }
        finally { l.unlock(); }
    }

    public final boolean isEmpty() {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.isEmpty(); }
        finally { l.unlock(); }
    }

    public final boolean contains(Object o) {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.contains(o); }
        finally { l.unlock(); }
    }

    public final boolean equals(Object o) {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.equals(o); }
        finally { l.unlock(); }
    }

    public final int hashCode() {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.hashCode(); }
        finally { l.unlock(); }
    }

    public final String toString() {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.toString(); }
        finally { l.unlock(); }
    }

    public final Iterator<E> iterator() {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.iterator(); }
        finally { l.unlock(); }
    }

    public final Object[] toArray() {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return c.toArray(); }
        finally { l.unlock(); }
    }

    public final <T> T[] toArray(T[] a) {
        final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
        l.lock();
        try { return (T[])c.toArray(a); }
        finally { l.unlock(); }
    }

    public final boolean add(E e) {
        final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
        l.lock();
        try { return c.add(e); }
        finally { l.unlock(); }
    }

    public final boolean remove(Object o) {
        final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
        l.lock();
        try { return c.remove(o); }
        finally { l.unlock(); }
    }

    public final boolean containsAll(Collection<?> coll) {
        final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
        l.lock();
        try { return c.containsAll(coll); }
        finally { l.unlock(); }
    }

    public final boolean addAll(Collection<? extends E> coll) {
        final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
        l.lock();
        try { return c.addAll(coll); }
        finally { l.unlock(); }
    }

    public final boolean removeAll(Collection<?> coll) {
        final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
        l.lock();
        try { return c.removeAll(coll); }
        finally { l.unlock(); }
    }

    public final boolean retainAll(Collection<?> coll) {
        final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
        l.lock();
        try { return c.retainAll(coll); }
        finally { l.unlock(); }
    }

    public final void clear() {
        final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
        l.lock();
        try { c.clear(); }
        finally { l.unlock(); }
    }

}
Revision:	1.6
Committed:	Sun Oct 21 06:40:21 2012 UTC (11 years, 6 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.5:	+0 -2 lines
Log Message:	no blank line between javadoc and corresponding code
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.4	* http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.1	*/
6			import java.util.*;
7			import java.util.concurrent.*;
8			import java.util.concurrent.locks.*;
9
10			/**
11			* This is an incomplete implementation of a wrapper class
12			* that places read-write locks around unsynchronized Collections.
13			* Exists as a sample input for CollectionLoops test.
14			*/
15			public final class RWCollection<E> implements Collection<E> {
16			private final Collection c;
17			private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
18	jsr166	1.2
19	dl	1.1	public RWCollection(Collection<E> c) {
20			if (c == null)
21			throw new NullPointerException();
22			this.c = c;
23			}
24
25	jsr166	1.2	public RWCollection() {
26			this(new ArrayList<E>());
27	dl	1.1	}
28
29			public final int size() {
30	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
31	jsr166	1.3	l.lock();
32			try { return c.size(); }
33			finally { l.unlock(); }
34	dl	1.1	}
35	jsr166	1.3
36			public final boolean isEmpty() {
37	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
38	jsr166	1.3	l.lock();
39			try { return c.isEmpty(); }
40			finally { l.unlock(); }
41	dl	1.1	}
42
43			public final boolean contains(Object o) {
44	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
45	jsr166	1.3	l.lock();
46			try { return c.contains(o); }
47			finally { l.unlock(); }
48	dl	1.1	}
49
50			public final boolean equals(Object o) {
51	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
52	jsr166	1.3	l.lock();
53			try { return c.equals(o); }
54			finally { l.unlock(); }
55	dl	1.1	}
56	jsr166	1.3
57	dl	1.1	public final int hashCode() {
58	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
59	jsr166	1.3	l.lock();
60			try { return c.hashCode(); }
61			finally { l.unlock(); }
62	dl	1.1	}
63	jsr166	1.3
64	dl	1.1	public final String toString() {
65	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
66	jsr166	1.3	l.lock();
67			try { return c.toString(); }
68			finally { l.unlock(); }
69	dl	1.1	}
70
71			public final Iterator<E> iterator() {
72	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
73	jsr166	1.3	l.lock();
74			try { return c.iterator(); }
75			finally { l.unlock(); }
76	dl	1.1	}
77
78			public final Object[] toArray() {
79	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
80	jsr166	1.3	l.lock();
81			try { return c.toArray(); }
82			finally { l.unlock(); }
83	dl	1.1	}
84	jsr166	1.3
85	dl	1.1	public final <T> T[] toArray(T[] a) {
86	jsr166	1.5	final ReentrantReadWriteLock.ReadLock l = rwl.readLock();
87	jsr166	1.3	l.lock();
88			try { return (T[])c.toArray(a); }
89			finally { l.unlock(); }
90	dl	1.1	}
91
92			public final boolean add(E e) {
93	jsr166	1.5	final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
94	jsr166	1.3	l.lock();
95			try { return c.add(e); }
96			finally { l.unlock(); }
97	dl	1.1	}
98	jsr166	1.3
99	dl	1.1	public final boolean remove(Object o) {
100	jsr166	1.5	final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
101	jsr166	1.3	l.lock();
102			try { return c.remove(o); }
103			finally { l.unlock(); }
104	dl	1.1	}
105
106			public final boolean containsAll(Collection<?> coll) {
107	jsr166	1.5	final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
108	jsr166	1.3	l.lock();
109			try { return c.containsAll(coll); }
110			finally { l.unlock(); }
111	dl	1.1	}
112	jsr166	1.3
113	dl	1.1	public final boolean addAll(Collection<? extends E> coll) {
114	jsr166	1.5	final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
115	jsr166	1.3	l.lock();
116			try { return c.addAll(coll); }
117			finally { l.unlock(); }
118	dl	1.1	}
119	jsr166	1.3
120	dl	1.1	public final boolean removeAll(Collection<?> coll) {
121	jsr166	1.5	final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
122	jsr166	1.3	l.lock();
123			try { return c.removeAll(coll); }
124			finally { l.unlock(); }
125	dl	1.1	}
126	jsr166	1.3
127	dl	1.1	public final boolean retainAll(Collection<?> coll) {
128	jsr166	1.5	final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
129	jsr166	1.3	l.lock();
130			try { return c.retainAll(coll); }
131			finally { l.unlock(); }
132	dl	1.1	}
133	jsr166	1.3
134	dl	1.1	public final void clear() {
135	jsr166	1.5	final ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
136	jsr166	1.3	l.lock();
137			try { c.clear(); }
138			finally { l.unlock(); }
139	dl	1.1	}
140
141			}