Fix SmartThreadPool line endings in recent update from dos to unix

author: Justin Clark-Casey (justincc) 2013-05-01 23:00:46 +0100
committer: Justin Clark-Casey (justincc) 2013-05-01 23:00:46 +0100
commit: 854dcd1abddc3eef33da953592deb61133e5e7ed (patch)
tree: d89d9d616384fdb4e6b4eec658339eac2f079ff2 /ThirdParty/SmartThreadPool/SynchronizedDictionary.cs
parent: Add in-code exaplanation for the change in cancellation signalling in STP 2.2... (diff)
download: opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.zip
opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.tar.gz
opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.tar.bz2
opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.tar.xz
1 files changed, 89 insertions, 89 deletions
diff --git a/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs b/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs
index 3532cca..0cce19f 100644
--- a/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs
+++ b/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs
@@ -1,89 +1,89 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
-namespace Amib.Threading.Internal
+namespace Amib.Threading.Internal
-{
+{
-    internal class SynchronizedDictionary<TKey, TValue>
+    internal class SynchronizedDictionary<TKey, TValue>
-    {
+    {
-        private readonly Dictionary<TKey, TValue> _dictionary;
+        private readonly Dictionary<TKey, TValue> _dictionary;
-        private readonly object _lock;
+        private readonly object _lock;
-        public SynchronizedDictionary()
+        public SynchronizedDictionary()
-        {
+        {
-            _lock = new object();
+            _lock = new object();
-            _dictionary = new Dictionary<TKey, TValue>();
+            _dictionary = new Dictionary<TKey, TValue>();
-        }
+        }
-        public int Count
+        public int Count
-        {
+        {
-            get { return _dictionary.Count; }
+            get { return _dictionary.Count; }
-        }
+        }
-        public bool Contains(TKey key)
+        public bool Contains(TKey key)
-        {
+        {
-            lock (_lock)
+            lock (_lock)
-            {
+            {
-                return _dictionary.ContainsKey(key);
+                return _dictionary.ContainsKey(key);
-            }
+            }
-        }
+        }
-        public void Remove(TKey key)
+        public void Remove(TKey key)
-        {
+        {
-            lock (_lock)
+            lock (_lock)
-            {
+            {
-                _dictionary.Remove(key);
+                _dictionary.Remove(key);
-            }
+            }
-        }
+        }
-        public object SyncRoot
+        public object SyncRoot
-        {
+        {
-            get { return _lock; }
+            get { return _lock; }
-        }
+        }
-        public TValue this[TKey key]
+        public TValue this[TKey key]
-        {
+        {
-            get
+            get
-            {
+            {
-                lock (_lock)
+                lock (_lock)
-                {
+                {
-                    return _dictionary[key];
+                    return _dictionary[key];
-                }
+                }
-            }
+            }
-            set
+            set
-            {
+            {
-                lock (_lock)
+                lock (_lock)
-                {
+                {
-                    _dictionary[key] = value;
+                    _dictionary[key] = value;
-                }
+                }
-            }
+            }
-        }
+        }
-        public Dictionary<TKey, TValue>.KeyCollection Keys
+        public Dictionary<TKey, TValue>.KeyCollection Keys
-        {
+        {
-            get
+            get
-            {
+            {
-                lock (_lock)
+                lock (_lock)
-                {
+                {
-                    return _dictionary.Keys;
+                    return _dictionary.Keys;
-                }
+                }
-            }
+            }
-        }
+        }
-        public Dictionary<TKey, TValue>.ValueCollection Values
+        public Dictionary<TKey, TValue>.ValueCollection Values
-        {
+        {
-            get
+            get
-            {
+            {
-                lock (_lock)
+                lock (_lock)
-                {
+                {
-                    return _dictionary.Values;
+                    return _dictionary.Values;
-                }
+                }
-            }
+            }
-        }
+        }
-        public void Clear()
+        public void Clear()
-        {
+        {
-            lock (_lock)
+            lock (_lock)
-            {
+            {
-                _dictionary.Clear();
+                _dictionary.Clear();
-            }
+            }
-        }
+        }
-    }
+    }
-}
+}
author	Justin Clark-Casey (justincc)	2013-05-01 23:00:46 +0100
committer	Justin Clark-Casey (justincc)	2013-05-01 23:00:46 +0100
commit	854dcd1abddc3eef33da953592deb61133e5e7ed (patch)
tree	d89d9d616384fdb4e6b4eec658339eac2f079ff2 /ThirdParty/SmartThreadPool/SynchronizedDictionary.cs
parent	Add in-code exaplanation for the change in cancellation signalling in STP 2.2... (diff)
download	opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.zip opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.tar.gz opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.tar.bz2 opensim-SC-854dcd1abddc3eef33da953592deb61133e5e7ed.tar.xz

diff --git a/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs b/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs index 3532cca..0cce19f 100644 --- a/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs +++ b/ThirdParty/SmartThreadPool/SynchronizedDictionary.cs
@@ -1,89 +1,89 @@
1	using System.Collections.Generic;	1	using System.Collections.Generic;
2		2
3	namespace Amib.Threading.Internal	3	namespace Amib.Threading.Internal
4	{	4	{
5	internal class SynchronizedDictionary<TKey, TValue>	5	internal class SynchronizedDictionary<TKey, TValue>
6	{	6	{
7	private readonly Dictionary<TKey, TValue> _dictionary;	7	private readonly Dictionary<TKey, TValue> _dictionary;
8	private readonly object _lock;	8	private readonly object _lock;
9		9
10	public SynchronizedDictionary()	10	public SynchronizedDictionary()
11	{	11	{
12	_lock = new object();	12	_lock = new object();
13	_dictionary = new Dictionary<TKey, TValue>();	13	_dictionary = new Dictionary<TKey, TValue>();
14	}	14	}
15		15
16	public int Count	16	public int Count
17	{	17	{
18	get { return _dictionary.Count; }	18	get { return _dictionary.Count; }
19	}	19	}
20		20
21	public bool Contains(TKey key)	21	public bool Contains(TKey key)
22	{	22	{
23	lock (_lock)	23	lock (_lock)
24	{	24	{
25	return _dictionary.ContainsKey(key);	25	return _dictionary.ContainsKey(key);
26	}	26	}
27	}	27	}
28		28
29	public void Remove(TKey key)	29	public void Remove(TKey key)
30	{	30	{
31	lock (_lock)	31	lock (_lock)
32	{	32	{
33	_dictionary.Remove(key);	33	_dictionary.Remove(key);
34	}	34	}
35	}	35	}
36		36
37	public object SyncRoot	37	public object SyncRoot
38	{	38	{
39	get { return _lock; }	39	get { return _lock; }
40	}	40	}
41		41
42	public TValue this[TKey key]	42	public TValue this[TKey key]
43	{	43	{
44	get	44	get
45	{	45	{
46	lock (_lock)	46	lock (_lock)
47	{	47	{
48	return _dictionary[key];	48	return _dictionary[key];
49	}	49	}
50	}	50	}
51	set	51	set
52	{	52	{
53	lock (_lock)	53	lock (_lock)
54	{	54	{
55	_dictionary[key] = value;	55	_dictionary[key] = value;
56	}	56	}
57	}	57	}
58	}	58	}
59		59
60	public Dictionary<TKey, TValue>.KeyCollection Keys	60	public Dictionary<TKey, TValue>.KeyCollection Keys
61	{	61	{
62	get	62	get
63	{	63	{
64	lock (_lock)	64	lock (_lock)
65	{	65	{
66	return _dictionary.Keys;	66	return _dictionary.Keys;
67	}	67	}
68	}	68	}
69	}	69	}
70		70
71	public Dictionary<TKey, TValue>.ValueCollection Values	71	public Dictionary<TKey, TValue>.ValueCollection Values
72	{	72	{
73	get	73	get
74	{	74	{
75	lock (_lock)	75	lock (_lock)
76	{	76	{
77	return _dictionary.Values;	77	return _dictionary.Values;
78	}	78	}
79	}	79	}
80	}	80	}
81	public void Clear()	81	public void Clear()
82	{	82	{
83	lock (_lock)	83	lock (_lock)
84	{	84	{
85	_dictionary.Clear();	85	_dictionary.Clear();
86	}	86	}
87	}	87	}
88	}	88	}
89	}	89	}