source: 2014/24/EemeliK/Zombieland/Jypeli/Physics2DDotNet/Collections/ReadOnlyThreadSafeCollection.cs @ 5974

Revision 5974, 9.1 KB checked in by empaheik, 5 years ago (diff)
Line 
1#region MIT License
2/*
3 * Copyright (c) 2005-2008 Jonathan Mark Porter. http://physics2d.googlepages.com/
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights to
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 * the Software, and to permit persons to whom the Software is furnished to do so,
10 * subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
16 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
19 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22#endregion
23
24
25
26using System;
27using System.Collections.Generic;
28namespace Physics2DDotNet.Collections
29{
30    public sealed class ReadOnlyThreadSafeCollection<T> : IList<T>
31    {
32        sealed class ThreadSafeEnumerator : IEnumerator<T>
33        {
34            AdvReaderWriterLock.ReaderLock readLock;
35            IEnumerator<T> self;
36
37            public ThreadSafeEnumerator(AdvReaderWriterLock.ReaderLock readLock, IEnumerator<T> self)
38            {
39                if (self == null) { throw new ArgumentNullException("self"); }
40                if (readLock == null) { throw new ArgumentNullException("readLock"); }
41                this.readLock = readLock;
42                this.self = self;
43            }
44            object System.Collections.IEnumerator.Current
45            {
46                get { return self.Current; }
47            }
48            public T Current
49            {
50                get { return self.Current; }
51            }
52
53            public void Dispose()
54            {
55                self.Dispose();
56                readLock.Dispose();
57            }
58            public bool MoveNext()
59            {
60                return self.MoveNext();
61            }
62            public void Reset()
63            {
64                self.Reset();
65            }
66        }
67
68        AdvReaderWriterLock rwLock;
69        List<T> self;
70        public ReadOnlyThreadSafeCollection(AdvReaderWriterLock rwLock, List<T> self)
71        {
72            this.rwLock = rwLock;
73            this.self = self;
74        }
75
76        public int Count
77        {
78            get
79            {
80                return self.Count;
81            }
82        }
83        public bool IsReadOnly
84        {
85            get { return true; }
86        }
87        public T this[int index]
88        {
89            get
90            {
91                using (rwLock.Read)
92                {
93                    return self[index];
94                }
95            }
96            set
97            {
98                throw new NotSupportedException();
99            }
100        }
101
102
103
104#if !(SILVERLIGHT || WINDOWS_PHONE || XBOX)
105        public List<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter)
106        {
107            using (rwLock.Read)
108            {
109                return self.ConvertAll<TOutput>(converter);
110            }
111        }
112        public bool Exists(Predicate<T> match)
113        {
114            using (rwLock.Read)
115            {
116                return self.Exists(match);
117            }
118        }
119        public T Find(Predicate<T> match)
120        {
121            using (rwLock.Read)
122            {
123                return self.Find(match);
124            }
125        }
126        public List<T> FindAll(Predicate<T> match)
127        {
128            using (rwLock.Read)
129            {
130                return self.FindAll(match);
131            }
132        }
133        public int FindIndex(Predicate<T> match)
134        {
135            using (rwLock.Read)
136            {
137                return self.FindIndex(match);
138            }
139        }
140        public int FindIndex(int startIndex, Predicate<T> match)
141        {
142            using (rwLock.Read)
143            {
144                return self.FindIndex(startIndex, match);
145            }
146        }
147        public int FindIndex(int startIndex, int count, Predicate<T> match)
148        {
149            using (rwLock.Read)
150            {
151                return self.FindIndex(startIndex, count, match);
152            }
153        }
154        public T FindLast(Predicate<T> match)
155        {
156            using (rwLock.Read)
157            {
158                return self.FindLast(match);
159            }
160        }
161        public int FindLastIndex(Predicate<T> match)
162        {
163            using (rwLock.Read)
164            {
165                return self.FindLastIndex(match);
166            }
167        }
168        public int FindLastIndex(int startIndex, Predicate<T> match)
169        {
170            using (rwLock.Read)
171            {
172                return self.FindLastIndex(startIndex, match);
173            }
174        }
175        public int FindLastIndex(int startIndex, int count, Predicate<T> match)
176        {
177            using (rwLock.Read)
178            {
179                return self.FindLastIndex(startIndex, count, match);
180            }
181        }
182        public bool TrueForAll(Predicate<T> match)
183        {
184            using (rwLock.Read)
185            {
186                return self.TrueForAll(match);
187            }
188        }
189#endif
190        public int BinarySearch(T item)
191        {
192            using (rwLock.Read)
193            {
194                return self.BinarySearch(item);
195            }
196        }
197        public int BinarySearch(T item, IComparer<T> comparer)
198        {
199            using (rwLock.Read)
200            {
201                return self.BinarySearch(item, comparer);
202            }
203        }
204        public int BinarySearch(int index, int count, T item, IComparer<T> comparer)
205        {
206            using (rwLock.Read)
207            {
208                return self.BinarySearch(index, count, item, comparer);
209            }
210        }
211
212        public bool Contains(T item)
213        {
214            using (rwLock.Read)
215            {
216                return self.Contains(item);
217            }
218        }
219
220        public void CopyTo(T[] array)
221        {
222            using (rwLock.Read)
223            {
224                self.CopyTo(array);
225            }
226        }
227        public void CopyTo(T[] array, int arrayIndex)
228        {
229            using (rwLock.Read)
230            {
231                self.CopyTo(array, arrayIndex);
232            }
233        }
234        public void CopyTo(int index, T[] array, int arrayIndex, int count)
235        {
236            using (rwLock.Read)
237            {
238                self.CopyTo(index, array, arrayIndex, count);
239            }
240        }
241
242        public List<T> GetRange(int index, int count)
243        {
244            using (rwLock.Read)
245            {
246                return self.GetRange(index, count);
247            }
248        }
249        public int IndexOf(T item)
250        {
251            using (rwLock.Read)
252            {
253                return self.IndexOf(item);
254            }
255        }
256        public int IndexOf(T item, int index)
257        {
258            using (rwLock.Read)
259            {
260                return self.IndexOf(item, index);
261            }
262        }
263        public int IndexOf(T item, int index, int count)
264        {
265            using (rwLock.Read)
266            {
267                return self.IndexOf(item, index, count);
268            }
269        }
270        public int LastIndexOf(T item)
271        {
272            using (rwLock.Read)
273            {
274                return self.LastIndexOf(item);
275            }
276        }
277        public int LastIndexOf(T item, int index)
278        {
279            using (rwLock.Read)
280            {
281                return self.LastIndexOf(item, index);
282            }
283        }
284        public int LastIndexOf(T item, int index, int count)
285        {
286            using (rwLock.Read)
287            {
288                return self.LastIndexOf(item, index, count);
289            }
290        }
291
292
293        public IEnumerator<T> GetEnumerator()
294        {
295            return new ThreadSafeEnumerator(rwLock.Read, self.GetEnumerator());
296        }
297
298        bool ICollection<T>.Remove(T item)
299        {
300            throw new NotSupportedException();
301        }
302        void IList<T>.Insert(int index, T item)
303        {
304            throw new NotSupportedException();
305        }
306        void IList<T>.RemoveAt(int index)
307        {
308            throw new NotSupportedException();
309        }
310        void ICollection<T>.Add(T item)
311        {
312            throw new NotSupportedException();
313        }
314        void ICollection<T>.Clear()
315        {
316            throw new NotSupportedException();
317        }
318        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
319        {
320            return new ThreadSafeEnumerator(rwLock.Read, self.GetEnumerator());
321        }
322    }
323}
Note: See TracBrowser for help on using the repository browser.