|
1
13
14 package EDU.oswego.cs.dl.util.concurrent;
15 import java.util.*;
16
17
27
28
29 public class SyncList extends SyncCollection implements List {
30
31
37 public SyncList(List list, Sync sync) {
38 super (list, sync);
39 }
40
41
45 public SyncList(List list, ReadWriteLock rwl) {
46 super (list, rwl.readLock(), rwl.writeLock());
47 }
48
49
53 public SyncList(List list, Sync readLock, Sync writeLock) {
54 super(list, readLock, writeLock);
55 }
56
57
58 protected List baseList() {
59 return (List)c_;
60 }
61
62
63 public int hashCode() {
64 boolean wasInterrupted = beforeRead();
65 try {
66 return c_.hashCode();
67 }
68 finally {
69 afterRead(wasInterrupted);
70 }
71 }
72
73 public boolean equals(Object  o) {
74 boolean wasInterrupted = beforeRead();
75 try {
76 return c_.equals(o);
77 }
78 finally {
79 afterRead(wasInterrupted);
80 }
81 }
82
83 public Object get(int index) {
84 boolean wasInterrupted = beforeRead();
85 try {
86 return baseList().get(index);
87 }
88 finally {
89 afterRead(wasInterrupted);
90 }
91 }
92
93 public int indexOf(Object o) {
94 boolean wasInterrupted = beforeRead();
95 try {
96 return baseList().indexOf(o);
97 }
98 finally {
99 afterRead(wasInterrupted);
100 }
101 }
102
103
104 public int lastIndexOf(Object o) {
105 boolean wasInterrupted = beforeRead();
106 try {
107 return baseList().lastIndexOf(o);
108 }
109 finally {
110 afterRead(wasInterrupted);
111 }
112 }
113
114
115
116 public List subList(int fromIndex, int toIndex) {
117 boolean wasInterrupted = beforeRead();
118 try {
119 return new SyncList(baseList().subList(fromIndex, toIndex), rd_, wr_);
120 }
121 finally {
122 afterRead(wasInterrupted);
123 }
124 }
125
126 public Object set(int index, Object o) {
127 try {
128 wr_.acquire();
129 try {
130 return baseList().set(index, o);
131 }
132 finally {
133 wr_.release();
134 }
135 }
136 catch (InterruptedException ex) {
137 Thread.currentThread().interrupt();
138 throw new UnsupportedOperationException ();
139 }
140 }
141
142
143 public Object remove(int index) {
144 try {
145 wr_.acquire();
146 try {
147 return baseList().remove(index);
148 }
149 finally {
150 wr_.release();
151 }
152 }
153 catch (InterruptedException ex) {
154 Thread.currentThread().interrupt();
155 throw new UnsupportedOperationException ();
156 }
157 }
158
159 public void add(int index, Object o) {
160 try {
161 wr_.acquire();
162 try {
163 baseList().add(index, o);
164 }
165 finally {
166 wr_.release();
167 }
168 }
169 catch (InterruptedException ex) {
170 Thread.currentThread().interrupt();
171 throw new UnsupportedOperationException ();
172 }
173 }
174
175 public boolean addAll(int index, Collection coll) {
176 try {
177 wr_.acquire();
178 try {
179 return baseList().addAll(index, coll);
180 }
181 finally {
182 wr_.release();
183 }
184 }
185 catch (InterruptedException ex) {
186 Thread.currentThread().interrupt();
187 throw new UnsupportedOperationException ();
188 }
189 }
190
191 public ListIterator unprotectedListIterator() {
192 boolean wasInterrupted = beforeRead();
193 try {
194 return baseList().listIterator();
195 }
196 finally {
197 afterRead(wasInterrupted);
198 }
199 }
200
201 public ListIterator listIterator() {
202 boolean wasInterrupted = beforeRead();
203 try {
204 return new SyncCollectionListIterator(baseList().listIterator());
205 }
206 finally {
207 afterRead(wasInterrupted);
208 }
209 }
210
211 public ListIterator unprotectedListIterator(int index) {
212 boolean wasInterrupted = beforeRead();
213 try {
214 return baseList().listIterator(index);
215 }
216 finally {
217 afterRead(wasInterrupted);
218 }
219 }
220
221 public ListIterator listIterator(int index) {
222 boolean wasInterrupted = beforeRead();
223 try {
224 return new SyncCollectionListIterator(baseList().listIterator(index));
225 }
226 finally {
227 afterRead(wasInterrupted);
228 }
229 }
230
231
232 public class SyncCollectionListIterator extends SyncCollectionIterator implements ListIterator {
233
234 SyncCollectionListIterator(Iterator baseIterator) {
235 super(baseIterator);
236 }
237
238 protected ListIterator baseListIterator() {
239 return (ListIterator)(baseIterator_);
240 }
241
242 public boolean hasPrevious() {
243 boolean wasInterrupted = beforeRead();
244 try {
245 return baseListIterator().hasPrevious();
246 }
247 finally {
248 afterRead(wasInterrupted);
249 }
250 }
251
252 public Object previous() {
253 boolean wasInterrupted = beforeRead();
254 try {
255 return baseListIterator().previous();
256 }
257 finally {
258 afterRead(wasInterrupted);
259 }
260 }
261
262 public int nextIndex() {
263 boolean wasInterrupted = beforeRead();
264 try {
265 return baseListIterator().nextIndex();
266 }
267 finally {
268 afterRead(wasInterrupted);
269 }
270 }
271
272
273 public int previousIndex() {
274 boolean wasInterrupted = beforeRead();
275 try {
276 return baseListIterator().previousIndex();
277 }
278 finally {
279 afterRead(wasInterrupted);
280 }
281 }
282
283
284 public void set(Object o) {
285 try {
286 wr_.acquire();
287 try {
288 baseListIterator().set(o);
289 }
290 finally {
291 wr_.release();
292 }
293 }
294 catch (InterruptedException ex) {
295 Thread.currentThread().interrupt();
296 throw new UnsupportedOperationException ();
297 }
298 }
299
300 public void add(Object o) {
301 try {
302 wr_.acquire();
303 try {
304 baseListIterator().add(o);
305 }
306 finally {
307 wr_.release();
308 }
309 }
310 catch (InterruptedException ex) {
311 Thread.currentThread().interrupt();
312 throw new UnsupportedOperationException ();
313 }
314 }
315
316
317 }
318
319 }
320
321
322 |
Popular Tags |
Java API By Example, From Geeks To Geeks.