1 files changed, 182 insertions, 182 deletions
diff --git a/OpenSim/Region/Environment/Scenes/EntityManager.cs b/OpenSim/Region/Environment/Scenes/EntityManager.cs
index be39878..eb29ead 100644
--- a/OpenSim/Region/Environment/Scenes/EntityManager.cs
+++ b/OpenSim/Region/Environment/Scenes/EntityManager.cs
@@ -1,182 +1,182 @@
-using System;
+using System;
-using System.Collections;
+using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using OpenMetaverse;
+using OpenMetaverse;
-namespace OpenSim.Region.Environment.Scenes
+namespace OpenSim.Region.Environment.Scenes
-{
+{
-    public class EntityManager : IEnumerable<EntityBase>
+    public class EntityManager : IEnumerable<EntityBase>
-    {
+    {
-        private readonly Dictionary<UUID,EntityBase> m_eb_uuid = new Dictionary<UUID, EntityBase>();
+        private readonly Dictionary<UUID,EntityBase> m_eb_uuid = new Dictionary<UUID, EntityBase>();
-        private readonly Dictionary<uint, EntityBase> m_eb_localID = new Dictionary<uint, EntityBase>();
+        private readonly Dictionary<uint, EntityBase> m_eb_localID = new Dictionary<uint, EntityBase>();
-        private readonly Object m_lock = new Object();
+        private readonly Object m_lock = new Object();
-        [Obsolete("Use Add() instead.")]
+        [Obsolete("Use Add() instead.")]
-        public void Add(UUID id, EntityBase eb)
+        public void Add(UUID id, EntityBase eb)
-        {
+        {
-            Add(eb);
+            Add(eb);
-        }
+        }
-        public void Add(EntityBase entity)
+        public void Add(EntityBase entity)
-        {
+        {
-            lock(m_lock)
+            lock(m_lock)
-            {
+            {
-                m_eb_uuid.Add(entity.UUID, entity);
+                m_eb_uuid.Add(entity.UUID, entity);
-                m_eb_localID.Add(entity.LocalId, entity);
+                m_eb_localID.Add(entity.LocalId, entity);
-            }
+            }
-        }
+        }
-        public void InsertOrReplace(EntityBase entity)
+        public void InsertOrReplace(EntityBase entity)
-        {
+        {
-            lock(m_lock)
+            lock(m_lock)
-            {
+            {
-                m_eb_uuid[entity.UUID] = entity;
+                m_eb_uuid[entity.UUID] = entity;
-                m_eb_localID[entity.LocalId] = entity;
+                m_eb_localID[entity.LocalId] = entity;
-            }
+            }
-        }
+        }
-        public void Clear()
+        public void Clear()
-        {
+        {
-            lock (m_lock)
+            lock (m_lock)
-            {
+            {
-                m_eb_uuid.Clear();
+                m_eb_uuid.Clear();
-                m_eb_localID.Clear();
+                m_eb_localID.Clear();
-            }
+            }
-        }
+        }
-        public int Count
+        public int Count
-        {
+        {
-            get
+            get
-            {
+            {
-                lock (m_lock)
+                lock (m_lock)
-                {
+                {
-                    return m_eb_uuid.Count;
+                    return m_eb_uuid.Count;
-                }
+                }
-            }
+            }
-        }
+        }
-        public bool ContainsKey(UUID id)
+        public bool ContainsKey(UUID id)
-        {
+        {
-            lock(m_lock)
+            lock(m_lock)
-            {
+            {
-                return m_eb_uuid.ContainsKey(id);
+                return m_eb_uuid.ContainsKey(id);
-            }
+            }
-        }
+        }
-        public bool ContainsKey(uint localID)
+        public bool ContainsKey(uint localID)
-        {
+        {
-            lock (m_lock)
+            lock (m_lock)
-            {
+            {
-                return m_eb_localID.ContainsKey(localID);
+                return m_eb_localID.ContainsKey(localID);
-            }
+            }
-        }
+        }
-        public bool Remove(uint localID)
+        public bool Remove(uint localID)
-        {
+        {
-            lock(m_lock)
+            lock(m_lock)
-            {
+            {
-                bool a = m_eb_uuid.Remove(m_eb_localID[localID].UUID);
+                bool a = m_eb_uuid.Remove(m_eb_localID[localID].UUID);
-                bool b =  m_eb_localID.Remove(localID);
+                bool b =  m_eb_localID.Remove(localID);
-                return a && b;
+                return a && b;
-            }
+            }
-        }
+        }
-        public bool Remove(UUID id)
+        public bool Remove(UUID id)
-        {
+        {
-            lock(m_lock)
+            lock(m_lock)
-            {
+            {
-                bool a = m_eb_localID.Remove(m_eb_uuid[id].LocalId);
+                bool a = m_eb_localID.Remove(m_eb_uuid[id].LocalId);
-                bool b = m_eb_uuid.Remove(id);
+                bool b = m_eb_uuid.Remove(id);
-                return a && b;
+                return a && b;
-            }
+            }
-        }
+        }
-        public List<EntityBase> GetAllByType<T>()
+        public List<EntityBase> GetAllByType<T>()
-        {
+        {
-            List<EntityBase> tmp = new List<EntityBase>();
+            List<EntityBase> tmp = new List<EntityBase>();
-            lock(m_lock)
+            lock(m_lock)
-            {
+            {
-                foreach (KeyValuePair<UUID, EntityBase> pair in m_eb_uuid)
+                foreach (KeyValuePair<UUID, EntityBase> pair in m_eb_uuid)
-                {
+                {
-                    if(pair.Value is T)
+                    if(pair.Value is T)
-                    {
+                    {
-                        tmp.Add(pair.Value);
+                        tmp.Add(pair.Value);
-                    }
+                    }
-                }
+                }
-            }
+            }
-            return tmp;
+            return tmp;
-        }
+        }
-        public List<EntityBase> GetEntities()
+        public List<EntityBase> GetEntities()
-        {
+        {
-            lock (m_lock)
+            lock (m_lock)
-            {
+            {
-                return new List<EntityBase>(m_eb_uuid.Values);
+                return new List<EntityBase>(m_eb_uuid.Values);
-            }
+            }
-        }
+        }
-        public EntityBase this[UUID id]
+        public EntityBase this[UUID id]
-        {
+        {
-            get
+            get
-            {
+            {
-                lock (m_lock)
+                lock (m_lock)
-                {
+                {
-                    return m_eb_uuid[id];
+                    return m_eb_uuid[id];
-                }
+                }
-            }
+            }
-            set
+            set
-            {
+            {
-                InsertOrReplace(value);
+                InsertOrReplace(value);
-            }
+            }
-        }
+        }
-        public EntityBase this[uint localID]
+        public EntityBase this[uint localID]
-        {
+        {
-            get
+            get
-            {
+            {
-                lock (m_lock)
+                lock (m_lock)
-                {
+                {
-                    return m_eb_localID[localID];
+                    return m_eb_localID[localID];
-                }
+                }
-            }
+            }
-            set
+            set
-            {
+            {
-                InsertOrReplace(value);
+                InsertOrReplace(value);
-            }
+            }
-        }
+        }
-        public bool TryGetValue(UUID key, out EntityBase obj)
+        public bool TryGetValue(UUID key, out EntityBase obj)
-        {
+        {
-            lock(m_lock)
+            lock(m_lock)
-            {
+            {
-                return m_eb_uuid.TryGetValue(key, out obj);
+                return m_eb_uuid.TryGetValue(key, out obj);
-            }
+            }
-        }
+        }
-        public bool TryGetValue(uint key, out EntityBase obj)
+        public bool TryGetValue(uint key, out EntityBase obj)
-        {
+        {
-            lock (m_lock)
+            lock (m_lock)
-            {
+            {
-                return m_eb_localID.TryGetValue(key, out obj);
+                return m_eb_localID.TryGetValue(key, out obj);
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// This could be optimised to work on the list 'live' rather than making a safe copy and iterating that.
+        /// This could be optimised to work on the list 'live' rather than making a safe copy and iterating that.
-        /// </summary>
+        /// </summary>
-        /// <returns></returns>
+        /// <returns></returns>
-        public IEnumerator<EntityBase> GetEnumerator()
+        public IEnumerator<EntityBase> GetEnumerator()
-        {
+        {
-            return GetEntities().GetEnumerator();
+            return GetEntities().GetEnumerator();
-        }
+        }
-        IEnumerator IEnumerable.GetEnumerator()
+        IEnumerator IEnumerable.GetEnumerator()
-        {
+        {
-            return GetEnumerator();
+            return GetEnumerator();
-        }
+        }
-    }
+    }
-}
+}

diff --git a/OpenSim/Region/Environment/Scenes/EntityManager.cs b/OpenSim/Region/Environment/Scenes/EntityManager.cs index be39878..eb29ead 100644 --- a/OpenSim/Region/Environment/Scenes/EntityManager.cs +++ b/OpenSim/Region/Environment/Scenes/EntityManager.cs
@@ -1,182 +1,182 @@
1	using System;	1	using System;
2	using System.Collections;	2	using System.Collections;
3	using System.Collections.Generic;	3	using System.Collections.Generic;
4	using OpenMetaverse;	4	using OpenMetaverse;
5		5
6	namespace OpenSim.Region.Environment.Scenes	6	namespace OpenSim.Region.Environment.Scenes
7	{	7	{
8	public class EntityManager : IEnumerable<EntityBase>	8	public class EntityManager : IEnumerable<EntityBase>
9	{	9	{
10	private readonly Dictionary<UUID,EntityBase> m_eb_uuid = new Dictionary<UUID, EntityBase>();	10	private readonly Dictionary<UUID,EntityBase> m_eb_uuid = new Dictionary<UUID, EntityBase>();
11	private readonly Dictionary<uint, EntityBase> m_eb_localID = new Dictionary<uint, EntityBase>();	11	private readonly Dictionary<uint, EntityBase> m_eb_localID = new Dictionary<uint, EntityBase>();
12	private readonly Object m_lock = new Object();	12	private readonly Object m_lock = new Object();
13		13
14	[Obsolete("Use Add() instead.")]	14	[Obsolete("Use Add() instead.")]
15	public void Add(UUID id, EntityBase eb)	15	public void Add(UUID id, EntityBase eb)
16	{	16	{
17	Add(eb);	17	Add(eb);
18	}	18	}
19		19
20	public void Add(EntityBase entity)	20	public void Add(EntityBase entity)
21	{	21	{
22	lock(m_lock)	22	lock(m_lock)
23	{	23	{
24	m_eb_uuid.Add(entity.UUID, entity);	24	m_eb_uuid.Add(entity.UUID, entity);
25	m_eb_localID.Add(entity.LocalId, entity);	25	m_eb_localID.Add(entity.LocalId, entity);
26	}	26	}
27	}	27	}
28		28
29	public void InsertOrReplace(EntityBase entity)	29	public void InsertOrReplace(EntityBase entity)
30	{	30	{
31	lock(m_lock)	31	lock(m_lock)
32	{	32	{
33	m_eb_uuid[entity.UUID] = entity;	33	m_eb_uuid[entity.UUID] = entity;
34	m_eb_localID[entity.LocalId] = entity;	34	m_eb_localID[entity.LocalId] = entity;
35	}	35	}
36	}	36	}
37		37
38	public void Clear()	38	public void Clear()
39	{	39	{
40	lock (m_lock)	40	lock (m_lock)
41	{	41	{
42	m_eb_uuid.Clear();	42	m_eb_uuid.Clear();
43	m_eb_localID.Clear();	43	m_eb_localID.Clear();
44	}	44	}
45	}	45	}
46		46
47	public int Count	47	public int Count
48	{	48	{
49	get	49	get
50	{	50	{
51	lock (m_lock)	51	lock (m_lock)
52	{	52	{
53	return m_eb_uuid.Count;	53	return m_eb_uuid.Count;
54	}	54	}
55	}	55	}
56	}	56	}
57		57
58	public bool ContainsKey(UUID id)	58	public bool ContainsKey(UUID id)
59	{	59	{
60	lock(m_lock)	60	lock(m_lock)
61	{	61	{
62	return m_eb_uuid.ContainsKey(id);	62	return m_eb_uuid.ContainsKey(id);
63	}	63	}
64	}	64	}
65		65
66	public bool ContainsKey(uint localID)	66	public bool ContainsKey(uint localID)
67	{	67	{
68	lock (m_lock)	68	lock (m_lock)
69	{	69	{
70	return m_eb_localID.ContainsKey(localID);	70	return m_eb_localID.ContainsKey(localID);
71	}	71	}
72	}	72	}
73		73
74	public bool Remove(uint localID)	74	public bool Remove(uint localID)
75	{	75	{
76	lock(m_lock)	76	lock(m_lock)
77	{	77	{
78	bool a = m_eb_uuid.Remove(m_eb_localID[localID].UUID);	78	bool a = m_eb_uuid.Remove(m_eb_localID[localID].UUID);
79	bool b = m_eb_localID.Remove(localID);	79	bool b = m_eb_localID.Remove(localID);
80		80
81	return a && b;	81	return a && b;
82	}	82	}
83	}	83	}
84		84
85	public bool Remove(UUID id)	85	public bool Remove(UUID id)
86	{	86	{
87	lock(m_lock)	87	lock(m_lock)
88	{	88	{
89	bool a = m_eb_localID.Remove(m_eb_uuid[id].LocalId);	89	bool a = m_eb_localID.Remove(m_eb_uuid[id].LocalId);
90	bool b = m_eb_uuid.Remove(id);	90	bool b = m_eb_uuid.Remove(id);
91		91
92	return a && b;	92	return a && b;
93	}	93	}
94	}	94	}
95		95
96	public List<EntityBase> GetAllByType<T>()	96	public List<EntityBase> GetAllByType<T>()
97	{	97	{
98	List<EntityBase> tmp = new List<EntityBase>();	98	List<EntityBase> tmp = new List<EntityBase>();
99		99
100	lock(m_lock)	100	lock(m_lock)
101	{	101	{
102	foreach (KeyValuePair<UUID, EntityBase> pair in m_eb_uuid)	102	foreach (KeyValuePair<UUID, EntityBase> pair in m_eb_uuid)
103	{	103	{
104	if(pair.Value is T)	104	if(pair.Value is T)
105	{	105	{
106	tmp.Add(pair.Value);	106	tmp.Add(pair.Value);
107	}	107	}
108	}	108	}
109	}	109	}
110		110
111	return tmp;	111	return tmp;
112	}	112	}
113		113
114	public List<EntityBase> GetEntities()	114	public List<EntityBase> GetEntities()
115	{	115	{
116	lock (m_lock)	116	lock (m_lock)
117	{	117	{
118	return new List<EntityBase>(m_eb_uuid.Values);	118	return new List<EntityBase>(m_eb_uuid.Values);
119	}	119	}
120	}	120	}
121		121
122	public EntityBase this[UUID id]	122	public EntityBase this[UUID id]
123	{	123	{
124	get	124	get
125	{	125	{
126	lock (m_lock)	126	lock (m_lock)
127	{	127	{
128	return m_eb_uuid[id];	128	return m_eb_uuid[id];
129	}	129	}
130	}	130	}
131	set	131	set
132	{	132	{
133	InsertOrReplace(value);	133	InsertOrReplace(value);
134	}	134	}
135	}	135	}
136		136
137	public EntityBase this[uint localID]	137	public EntityBase this[uint localID]
138	{	138	{
139	get	139	get
140	{	140	{
141	lock (m_lock)	141	lock (m_lock)
142	{	142	{
143	return m_eb_localID[localID];	143	return m_eb_localID[localID];
144	}	144	}
145	}	145	}
146	set	146	set
147	{	147	{
148	InsertOrReplace(value);	148	InsertOrReplace(value);
149	}	149	}
150	}	150	}
151		151
152	public bool TryGetValue(UUID key, out EntityBase obj)	152	public bool TryGetValue(UUID key, out EntityBase obj)
153	{	153	{
154	lock(m_lock)	154	lock(m_lock)
155	{	155	{
156	return m_eb_uuid.TryGetValue(key, out obj);	156	return m_eb_uuid.TryGetValue(key, out obj);
157	}	157	}
158	}	158	}
159		159
160	public bool TryGetValue(uint key, out EntityBase obj)	160	public bool TryGetValue(uint key, out EntityBase obj)
161	{	161	{
162	lock (m_lock)	162	lock (m_lock)
163	{	163	{
164	return m_eb_localID.TryGetValue(key, out obj);	164	return m_eb_localID.TryGetValue(key, out obj);
165	}	165	}
166	}	166	}
167		167
168	/// <summary>	168	/// <summary>
169	/// This could be optimised to work on the list 'live' rather than making a safe copy and iterating that.	169	/// This could be optimised to work on the list 'live' rather than making a safe copy and iterating that.
170	/// </summary>	170	/// </summary>
171	/// <returns></returns>	171	/// <returns></returns>
172	public IEnumerator<EntityBase> GetEnumerator()	172	public IEnumerator<EntityBase> GetEnumerator()
173	{	173	{
174	return GetEntities().GetEnumerator();	174	return GetEntities().GetEnumerator();
175	}	175	}
176		176
177	IEnumerator IEnumerable.GetEnumerator()	177	IEnumerator IEnumerable.GetEnumerator()
178	{	178	{
179	return GetEnumerator();	179	return GetEnumerator();
180	}	180	}
181	}	181	}
182	}	182	}