wasSharp – Diff between revs 44 and 54

Subversion Repositories:
Rev:
Only display areas with differences – Ignore whitespace
Rev 44 Rev 54
1 /////////////////////////////////////////////////////////////////////////// 1 ///////////////////////////////////////////////////////////////////////////
2 // Copyright (C) Wizardry and Steamworks 2017 - License: GNU GPLv3 // 2 // Copyright (C) Wizardry and Steamworks 2017 - License: GNU GPLv3 //
3 // Please see: http://www.gnu.org/licenses/gpl.html for legal details, // 3 // Please see: http://www.gnu.org/licenses/gpl.html for legal details, //
4 // rights of fair usage, the disclaimer and warranty conditions. // 4 // rights of fair usage, the disclaimer and warranty conditions. //
5 /////////////////////////////////////////////////////////////////////////// 5 ///////////////////////////////////////////////////////////////////////////
6   6  
7 using System.Collections; 7 using System.Collections;
8 using System.Collections.Generic; 8 using System.Collections.Generic;
9 using System.Threading; 9 using System.Threading;
10   10  
11 namespace wasSharp.Collections.Specialized 11 namespace wasSharp.Collections.Specialized
12 { 12 {
13 public static class ConcurrentListExtensions 13 public static class ConcurrentListExtensions
14 { 14 {
15 public static ConcurrentList<T> ToConcurrentList<T>(this IEnumerable<T> enumerable) 15 public static ConcurrentList<T> ToConcurrentList<T>(this IEnumerable<T> enumerable)
16 { 16 {
17 return new ConcurrentList<T>(enumerable); 17 return new ConcurrentList<T>(enumerable);
18 } 18 }
19 } 19 }
20   20  
21 public class ConcurrentList<T> : IList<T> 21 public class ConcurrentList<T> : IList<T>
22 { 22 {
23 private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion); 23 private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
24 private readonly List<T> _list; 24 private readonly List<T> _list;
25   25  
26 public ConcurrentList(IEnumerable<T> v) 26 public ConcurrentList(IEnumerable<T> v)
27 { 27 {
28 _lock.EnterWriteLock(); 28 _lock.EnterWriteLock();
29 try 29 try
30 { 30 {
31 _list = new List<T>(); 31 _list = new List<T>();
32 foreach (var i in v) 32 foreach (var i in v)
33 { 33 {
34 _list.Add(i); 34 _list.Add(i);
35 } 35 }
36 } 36 }
37 finally 37 finally
38 { 38 {
39 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 39 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
40 } 40 }
41 } 41 }
42   42  
43 public ConcurrentList() 43 public ConcurrentList()
44 { 44 {
45 _lock.EnterWriteLock(); 45 _lock.EnterWriteLock();
46 try 46 try
47 { 47 {
48 _list = new List<T>(); 48 _list = new List<T>();
49 } 49 }
50 finally 50 finally
51 { 51 {
52 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 52 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
53 } 53 }
54 } 54 }
55   55  
56 public int Count 56 public bool IsReadOnly
57 { 57 {
58 get 58 get
59 { 59 {
60 _lock.EnterReadLock(); 60 _lock.EnterReadLock();
61 try 61 try
62 { 62 {
63 return _list.Count; 63 return ((IList<T>)_list).IsReadOnly;
64 } 64 }
65 finally 65 finally
66 { 66 {
67 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 67 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
68 } 68 }
69 -  
70 } 69 }
71 } 70 }
72   71  
73 public bool IsReadOnly 72 int ICollection<T>.Count
74 { 73 {
75 get 74 get
76 { 75 {
77 _lock.EnterReadLock(); 76 _lock.EnterReadLock();
78 try 77 try
79 { 78 {
80 return ((IList<T>)_list).IsReadOnly; 79 return _list.Count;
81 } 80 }
82 finally 81 finally
83 { 82 {
84 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 83 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
85 } 84 }
86 } 85 }
87 } 86 }
88   87  
89 public T this[int index] 88 public T this[int index]
90 { 89 {
91 get 90 get
92 { 91 {
93 _lock.EnterReadLock(); 92 _lock.EnterReadLock();
94 try 93 try
95 { 94 {
96 return _list[index]; 95 return _list[index];
97 } 96 }
98 finally 97 finally
99 { 98 {
100 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 99 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
101 } 100 }
102 } 101 }
103   102  
104 set 103 set
105 { 104 {
106 _lock.EnterWriteLock(); 105 _lock.EnterWriteLock();
107 try 106 try
108 { 107 {
109 _list[index] = value; 108 _list[index] = value;
110 } 109 }
111 finally 110 finally
112 { 111 {
113 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 112 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
114 } 113 }
115 } 114 }
116 } 115 }
117   116  
118 public int IndexOf(T item) 117 public int IndexOf(T item)
119 { 118 {
120 _lock.EnterReadLock(); 119 _lock.EnterReadLock();
121 try 120 try
122 { 121 {
123 return _list.IndexOf(item); 122 return _list.IndexOf(item);
124 } 123 }
125 finally 124 finally
126 { 125 {
127 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 126 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
128 } 127 }
129 } 128 }
130   129  
131 public void Insert(int index, T item) 130 public void Insert(int index, T item)
132 { 131 {
133 _lock.EnterWriteLock(); 132 _lock.EnterWriteLock();
134 try 133 try
135 { 134 {
136 _list.Insert(index, item); 135 _list.Insert(index, item);
137 } 136 }
138 finally 137 finally
139 { 138 {
140 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 139 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
141 } 140 }
142 } 141 }
143   142  
144 public void RemoveAt(int index) 143 public void RemoveAt(int index)
145 { 144 {
146 _lock.EnterWriteLock(); 145 _lock.EnterWriteLock();
147 try 146 try
148 { 147 {
149 _list.RemoveAt(index); 148 _list.RemoveAt(index);
150 } 149 }
151 finally 150 finally
152 { 151 {
153 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 152 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
154 } 153 }
155 } 154 }
156   155  
157 public void Add(T item) 156 public void Add(T item)
158 { 157 {
159 _lock.EnterWriteLock(); 158 _lock.EnterWriteLock();
160 try 159 try
161 { 160 {
162 _list.Add(item); 161 _list.Add(item);
163 } 162 }
164 finally 163 finally
165 { 164 {
166 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 165 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
167 } 166 }
168 } 167 }
169   168  
170 public void Clear() 169 public void Clear()
171 { 170 {
172 _lock.EnterWriteLock(); 171 _lock.EnterWriteLock();
173 try 172 try
174 { 173 {
175 _list.Clear(); 174 _list.Clear();
176 } 175 }
177 finally 176 finally
178 { 177 {
179 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 178 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
180 } 179 }
181 } 180 }
182   181  
183 public bool Contains(T item) 182 public bool Contains(T item)
184 { 183 {
185 _lock.EnterReadLock(); 184 _lock.EnterReadLock();
186 try 185 try
187 { 186 {
188 return _list.Contains(item); 187 return _list.Contains(item);
189 } 188 }
190 finally 189 finally
191 { 190 {
192 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 191 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
193 } 192 }
194 } 193 }
195   194  
196 public void CopyTo(T[] array, int arrayIndex) 195 public void CopyTo(T[] array, int arrayIndex)
197 { 196 {
198 _lock.EnterReadLock(); 197 _lock.EnterReadLock();
199 try 198 try
200 { 199 {
201 _list.CopyTo(array, arrayIndex); 200 _list.CopyTo(array, arrayIndex);
202 } 201 }
203 finally 202 finally
204 { 203 {
205 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 204 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
206 } 205 }
207 } 206 }
208   207  
209 public bool Remove(T item) 208 public bool Remove(T item)
210 { 209 {
211 _lock.EnterWriteLock(); 210 _lock.EnterWriteLock();
212 try 211 try
213 { 212 {
214 return _list.Remove(item); 213 return _list.Remove(item);
215 } 214 }
216 finally 215 finally
217 { 216 {
218 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock(); 217 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
219 } 218 }
220 } 219 }
221   220  
222 public IEnumerator<T> GetEnumerator() 221 public IEnumerator<T> GetEnumerator()
223 { 222 {
224 _lock.EnterReadLock(); 223 _lock.EnterReadLock();
225 try 224 try
226 { 225 {
227 using (var enumerator = _list.GetEnumerator()) 226 using (var enumerator = _list.GetEnumerator())
228 { 227 {
229 while (enumerator.MoveNext()) 228 while (enumerator.MoveNext())
230 yield return enumerator.Current; 229 yield return enumerator.Current;
231 } 230 }
232 } 231 }
233 finally 232 finally
234 { 233 {
235 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 234 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
236 } 235 }
237 } 236 }
238   237  
239 IEnumerator IEnumerable.GetEnumerator() 238 IEnumerator IEnumerable.GetEnumerator()
240 { 239 {
241 _lock.EnterReadLock(); 240 _lock.EnterReadLock();
242 try 241 try
243 { 242 {
244 using (var enumerator = _list.GetEnumerator()) 243 using (var enumerator = _list.GetEnumerator())
245 { 244 {
246 while (enumerator.MoveNext()) 245 while (enumerator.MoveNext())
247 yield return enumerator.Current; 246 yield return enumerator.Current;
248 } 247 }
249 } 248 }
250 finally 249 finally
251 { 250 {
252 if (_lock.IsReadLockHeld) _lock.ExitReadLock(); 251 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
253 } 252 }
254 } 253 }
255 } 254 }
256 } 255 }
257   256