ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/loops/RWCollection.java
(Generate patch)

Comparing jsr166/src/test/loops/RWCollection.java (file contents):
Revision 1.2 by jsr166, Thu Oct 29 23:09:08 2009 UTC vs.
Revision 1.3 by jsr166, Sat Oct 16 16:22:57 2010 UTC

# Line 30 | Line 30 | public final class RWCollection<E> imple
30  
31      public final int size() {
32          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
33 <        l.lock(); try {return c.size();} finally { l.unlock(); }
33 >        l.lock();
34 >        try { return c.size(); }
35 >        finally { l.unlock(); }
36      }
37 <    public final boolean isEmpty(){
37 >
38 >    public final boolean isEmpty() {
39          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
40 <        l.lock(); try {return c.isEmpty();} finally { l.unlock(); }
40 >        l.lock();
41 >        try { return c.isEmpty(); }
42 >        finally { l.unlock(); }
43      }
44  
45      public final boolean contains(Object o) {
46          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
47 <        l.lock(); try {return c.contains(o);} finally { l.unlock(); }
47 >        l.lock();
48 >        try { return c.contains(o); }
49 >        finally { l.unlock(); }
50      }
51  
52      public final boolean equals(Object o) {
53          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
54 <        l.lock(); try {return c.equals(o);} finally { l.unlock(); }
54 >        l.lock();
55 >        try { return c.equals(o); }
56 >        finally { l.unlock(); }
57      }
58 +
59      public final int hashCode() {
60          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
61 <        l.lock(); try {return c.hashCode();} finally { l.unlock(); }
61 >        l.lock();
62 >        try { return c.hashCode(); }
63 >        finally { l.unlock(); }
64      }
65 +
66      public final String toString() {
67          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
68 <        l.lock(); try {return c.toString();} finally { l.unlock(); }
68 >        l.lock();
69 >        try { return c.toString(); }
70 >        finally { l.unlock(); }
71      }
72  
73      public final Iterator<E> iterator() {
74          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
75 <        l.lock(); try {return c.iterator();} finally { l.unlock(); }
75 >        l.lock();
76 >        try { return c.iterator(); }
77 >        finally { l.unlock(); }
78      }
79  
80      public final Object[] toArray() {
81          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
82 <        l.lock(); try  {return c.toArray();} finally { l.unlock(); }
82 >        l.lock();
83 >        try { return c.toArray(); }
84 >        finally { l.unlock(); }
85      }
86 +
87      public final <T> T[] toArray(T[] a) {
88          final ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
89 <        l.lock(); try  {return (T[])c.toArray(a);} finally { l.unlock(); }
89 >        l.lock();
90 >        try { return (T[])c.toArray(a); }
91 >        finally { l.unlock(); }
92      }
93  
94      public final boolean add(E e) {
95          final ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
96 <        l.lock(); try  {return c.add(e);} finally { l.unlock(); }
96 >        l.lock();
97 >        try { return c.add(e); }
98 >        finally { l.unlock(); }
99      }
100 +
101      public final boolean remove(Object o) {
102          final ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
103 <        l.lock(); try  {return c.remove(o);} finally { l.unlock(); }
103 >        l.lock();
104 >        try { return c.remove(o); }
105 >        finally { l.unlock(); }
106      }
107  
108      public final boolean containsAll(Collection<?> coll) {
109          final ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
110 <        l.lock(); try  {return c.containsAll(coll);} finally { l.unlock(); }
110 >        l.lock();
111 >        try { return c.containsAll(coll); }
112 >        finally { l.unlock(); }
113      }
114 +
115      public final boolean addAll(Collection<? extends E> coll) {
116          final ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
117 <        l.lock(); try  {return c.addAll(coll);} finally { l.unlock(); }
117 >        l.lock();
118 >        try { return c.addAll(coll); }
119 >        finally { l.unlock(); }
120      }
121 +
122      public final boolean removeAll(Collection<?> coll) {
123          final ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
124 <        l.lock(); try  {return c.removeAll(coll);} finally { l.unlock(); }
124 >        l.lock();
125 >        try { return c.removeAll(coll); }
126 >        finally { l.unlock(); }
127      }
128 +
129      public final boolean retainAll(Collection<?> coll) {
130          final ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
131 <        l.lock(); try  {return c.retainAll(coll);} finally { l.unlock(); }
131 >        l.lock();
132 >        try { return c.retainAll(coll); }
133 >        finally { l.unlock(); }
134      }
135 +
136      public final void clear() {
137          final ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
138 <        l.lock(); try  {c.clear();} finally { l.unlock(); }
138 >        l.lock();
139 >        try { c.clear(); }
140 >        finally { l.unlock(); }
141      }
142  
143   }

Diff Legend

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