diff options
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Framework/InventoryFolderImpl.cs (renamed from OpenSim/Framework/Communications/Cache/InventoryFolderImpl.cs) | 936 |
1 files changed, 466 insertions, 470 deletions
diff --git a/OpenSim/Framework/Communications/Cache/InventoryFolderImpl.cs b/OpenSim/Framework/InventoryFolderImpl.cs index 71f6f1b..248783f 100644 --- a/OpenSim/Framework/Communications/Cache/InventoryFolderImpl.cs +++ b/OpenSim/Framework/InventoryFolderImpl.cs | |||
@@ -1,470 +1,466 @@ | |||
1 | /* | 1 | /* |
2 | * Copyright (c) Contributors, http://opensimulator.org/ | 2 | * Copyright (c) Contributors, http://opensimulator.org/ |
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | 3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. |
4 | * | 4 | * |
5 | * Redistribution and use in source and binary forms, with or without | 5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions are met: | 6 | * modification, are permitted provided that the following conditions are met: |
7 | * * Redistributions of source code must retain the above copyright | 7 | * * Redistributions of source code must retain the above copyright |
8 | * notice, this list of conditions and the following disclaimer. | 8 | * notice, this list of conditions and the following disclaimer. |
9 | * * Redistributions in binary form must reproduce the above copyright | 9 | * * Redistributions in binary form must reproduce the above copyright |
10 | * notice, this list of conditions and the following disclaimer in the | 10 | * notice, this list of conditions and the following disclaimer in the |
11 | * documentation and/or other materials provided with the distribution. | 11 | * documentation and/or other materials provided with the distribution. |
12 | * * Neither the name of the OpenSimulator Project nor the | 12 | * * Neither the name of the OpenSimulator Project nor the |
13 | * names of its contributors may be used to endorse or promote products | 13 | * names of its contributors may be used to endorse or promote products |
14 | * derived from this software without specific prior written permission. | 14 | * derived from this software without specific prior written permission. |
15 | * | 15 | * |
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | 16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY |
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | 17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | 18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | 19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY |
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | 20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | 21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | 22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | 24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
26 | */ | 26 | */ |
27 | 27 | ||
28 | using System; | 28 | using System; |
29 | using System.Collections.Generic; | 29 | using System.Collections.Generic; |
30 | using OpenMetaverse; | 30 | using OpenMetaverse; |
31 | 31 | ||
32 | //using System.Reflection; | 32 | namespace OpenSim.Framework |
33 | 33 | { | |
34 | //using log4net; | 34 | public class InventoryFolderImpl : InventoryFolderBase |
35 | 35 | { | |
36 | namespace OpenSim.Framework.Communications.Cache | 36 | //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); |
37 | { | 37 | |
38 | public class InventoryFolderImpl : InventoryFolderBase | 38 | public static readonly string PATH_DELIMITER = "/"; |
39 | { | 39 | |
40 | //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | 40 | /// <summary> |
41 | 41 | /// Items that are contained in this folder | |
42 | public static readonly string PATH_DELIMITER = "/"; | 42 | /// </summary> |
43 | 43 | public Dictionary<UUID, InventoryItemBase> Items = new Dictionary<UUID, InventoryItemBase>(); | |
44 | /// <summary> | 44 | |
45 | /// Items that are contained in this folder | 45 | /// <summary> |
46 | /// </summary> | 46 | /// Child folders that are contained in this folder |
47 | public Dictionary<UUID, InventoryItemBase> Items = new Dictionary<UUID, InventoryItemBase>(); | 47 | /// </summary> |
48 | 48 | protected Dictionary<UUID, InventoryFolderImpl> m_childFolders = new Dictionary<UUID, InventoryFolderImpl>(); | |
49 | /// <summary> | 49 | |
50 | /// Child folders that are contained in this folder | 50 | // Constructors |
51 | /// </summary> | 51 | public InventoryFolderImpl(InventoryFolderBase folderbase) |
52 | protected Dictionary<UUID, InventoryFolderImpl> m_childFolders = new Dictionary<UUID, InventoryFolderImpl>(); | 52 | { |
53 | 53 | Owner = folderbase.Owner; | |
54 | // Constructors | 54 | ID = folderbase.ID; |
55 | public InventoryFolderImpl(InventoryFolderBase folderbase) | 55 | Name = folderbase.Name; |
56 | { | 56 | ParentID = folderbase.ParentID; |
57 | Owner = folderbase.Owner; | 57 | Type = folderbase.Type; |
58 | ID = folderbase.ID; | 58 | Version = folderbase.Version; |
59 | Name = folderbase.Name; | 59 | } |
60 | ParentID = folderbase.ParentID; | 60 | |
61 | Type = folderbase.Type; | 61 | public InventoryFolderImpl() |
62 | Version = folderbase.Version; | 62 | { |
63 | } | 63 | } |
64 | 64 | ||
65 | public InventoryFolderImpl() | 65 | /// <summary> |
66 | { | 66 | /// Create a new subfolder. |
67 | } | 67 | /// </summary> |
68 | 68 | /// <param name="folderID"></param> | |
69 | /// <summary> | 69 | /// <param name="folderName"></param> |
70 | /// Create a new subfolder. | 70 | /// <param name="type"></param> |
71 | /// </summary> | 71 | /// <returns>The newly created subfolder. Returns null if the folder already exists</returns> |
72 | /// <param name="folderID"></param> | 72 | public InventoryFolderImpl CreateChildFolder(UUID folderID, string folderName, ushort type) |
73 | /// <param name="folderName"></param> | 73 | { |
74 | /// <param name="type"></param> | 74 | lock (m_childFolders) |
75 | /// <returns>The newly created subfolder. Returns null if the folder already exists</returns> | 75 | { |
76 | public InventoryFolderImpl CreateChildFolder(UUID folderID, string folderName, ushort type) | 76 | if (!m_childFolders.ContainsKey(folderID)) |
77 | { | 77 | { |
78 | lock (m_childFolders) | 78 | InventoryFolderImpl subFold = new InventoryFolderImpl(); |
79 | { | 79 | subFold.Name = folderName; |
80 | if (!m_childFolders.ContainsKey(folderID)) | 80 | subFold.ID = folderID; |
81 | { | 81 | subFold.Type = (short)type; |
82 | InventoryFolderImpl subFold = new InventoryFolderImpl(); | 82 | subFold.ParentID = this.ID; |
83 | subFold.Name = folderName; | 83 | subFold.Owner = Owner; |
84 | subFold.ID = folderID; | 84 | m_childFolders.Add(subFold.ID, subFold); |
85 | subFold.Type = (short) type; | 85 | |
86 | subFold.ParentID = this.ID; | 86 | return subFold; |
87 | subFold.Owner = Owner; | 87 | } |
88 | m_childFolders.Add(subFold.ID, subFold); | 88 | } |
89 | 89 | ||
90 | return subFold; | 90 | return null; |
91 | } | 91 | } |
92 | } | 92 | |
93 | 93 | /// <summary> | |
94 | return null; | 94 | /// Add a folder that already exists. |
95 | } | 95 | /// </summary> |
96 | 96 | /// <param name="folder"></param> | |
97 | /// <summary> | 97 | public void AddChildFolder(InventoryFolderImpl folder) |
98 | /// Add a folder that already exists. | 98 | { |
99 | /// </summary> | 99 | lock (m_childFolders) |
100 | /// <param name="folder"></param> | 100 | { |
101 | public void AddChildFolder(InventoryFolderImpl folder) | 101 | folder.ParentID = ID; |
102 | { | 102 | m_childFolders[folder.ID] = folder; |
103 | lock (m_childFolders) | 103 | } |
104 | { | 104 | } |
105 | folder.ParentID = ID; | 105 | |
106 | m_childFolders[folder.ID] = folder; | 106 | /// <summary> |
107 | } | 107 | /// Does this folder contain the given child folder? |
108 | } | 108 | /// </summary> |
109 | 109 | /// <param name="folderID"></param> | |
110 | /// <summary> | 110 | /// <returns></returns> |
111 | /// Does this folder contain the given child folder? | 111 | public bool ContainsChildFolder(UUID folderID) |
112 | /// </summary> | 112 | { |
113 | /// <param name="folderID"></param> | 113 | return m_childFolders.ContainsKey(folderID); |
114 | /// <returns></returns> | 114 | } |
115 | public bool ContainsChildFolder(UUID folderID) | 115 | |
116 | { | 116 | /// <summary> |
117 | return m_childFolders.ContainsKey(folderID); | 117 | /// Get a child folder |
118 | } | 118 | /// </summary> |
119 | 119 | /// <param name="folderID"></param> | |
120 | /// <summary> | 120 | /// <returns>The folder if it exists, null if it doesn't</returns> |
121 | /// Get a child folder | 121 | public InventoryFolderImpl GetChildFolder(UUID folderID) |
122 | /// </summary> | 122 | { |
123 | /// <param name="folderID"></param> | 123 | InventoryFolderImpl folder = null; |
124 | /// <returns>The folder if it exists, null if it doesn't</returns> | 124 | |
125 | public InventoryFolderImpl GetChildFolder(UUID folderID) | 125 | lock (m_childFolders) |
126 | { | 126 | { |
127 | InventoryFolderImpl folder = null; | 127 | m_childFolders.TryGetValue(folderID, out folder); |
128 | 128 | } | |
129 | lock (m_childFolders) | 129 | |
130 | { | 130 | return folder; |
131 | m_childFolders.TryGetValue(folderID, out folder); | 131 | } |
132 | } | 132 | |
133 | 133 | /// <summary> | |
134 | return folder; | 134 | /// Removes the given child subfolder. |
135 | } | 135 | /// </summary> |
136 | 136 | /// <param name="folderID"></param> | |
137 | /// <summary> | 137 | /// <returns> |
138 | /// Removes the given child subfolder. | 138 | /// The folder removed, or null if the folder was not present. |
139 | /// </summary> | 139 | /// </returns> |
140 | /// <param name="folderID"></param> | 140 | public InventoryFolderImpl RemoveChildFolder(UUID folderID) |
141 | /// <returns> | 141 | { |
142 | /// The folder removed, or null if the folder was not present. | 142 | InventoryFolderImpl removedFolder = null; |
143 | /// </returns> | 143 | |
144 | public InventoryFolderImpl RemoveChildFolder(UUID folderID) | 144 | lock (m_childFolders) |
145 | { | 145 | { |
146 | InventoryFolderImpl removedFolder = null; | 146 | if (m_childFolders.ContainsKey(folderID)) |
147 | 147 | { | |
148 | lock (m_childFolders) | 148 | removedFolder = m_childFolders[folderID]; |
149 | { | 149 | m_childFolders.Remove(folderID); |
150 | if (m_childFolders.ContainsKey(folderID)) | 150 | } |
151 | { | 151 | } |
152 | removedFolder = m_childFolders[folderID]; | 152 | |
153 | m_childFolders.Remove(folderID); | 153 | return removedFolder; |
154 | } | 154 | } |
155 | } | 155 | |
156 | 156 | /// <summary> | |
157 | return removedFolder; | 157 | /// Delete all the folders and items in this folder. |
158 | } | 158 | /// </summary> |
159 | 159 | public void Purge() | |
160 | /// <summary> | 160 | { |
161 | /// Delete all the folders and items in this folder. | 161 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
162 | /// </summary> | 162 | { |
163 | public void Purge() | 163 | folder.Purge(); |
164 | { | 164 | } |
165 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 165 | |
166 | { | 166 | m_childFolders.Clear(); |
167 | folder.Purge(); | 167 | Items.Clear(); |
168 | } | 168 | } |
169 | 169 | ||
170 | m_childFolders.Clear(); | 170 | /// <summary> |
171 | Items.Clear(); | 171 | /// Returns the item if it exists in this folder or in any of this folder's descendant folders |
172 | } | 172 | /// </summary> |
173 | 173 | /// <param name="itemID"></param> | |
174 | /// <summary> | 174 | /// <returns>null if the item is not found</returns> |
175 | /// Returns the item if it exists in this folder or in any of this folder's descendant folders | 175 | public InventoryItemBase FindItem(UUID itemID) |
176 | /// </summary> | 176 | { |
177 | /// <param name="itemID"></param> | 177 | lock (Items) |
178 | /// <returns>null if the item is not found</returns> | 178 | { |
179 | public InventoryItemBase FindItem(UUID itemID) | 179 | if (Items.ContainsKey(itemID)) |
180 | { | 180 | { |
181 | lock (Items) | 181 | return Items[itemID]; |
182 | { | 182 | } |
183 | if (Items.ContainsKey(itemID)) | 183 | } |
184 | { | 184 | |
185 | return Items[itemID]; | 185 | lock (m_childFolders) |
186 | } | 186 | { |
187 | } | 187 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
188 | 188 | { | |
189 | lock (m_childFolders) | 189 | InventoryItemBase item = folder.FindItem(itemID); |
190 | { | 190 | |
191 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 191 | if (item != null) |
192 | { | 192 | { |
193 | InventoryItemBase item = folder.FindItem(itemID); | 193 | return item; |
194 | 194 | } | |
195 | if (item != null) | 195 | } |
196 | { | 196 | } |
197 | return item; | 197 | |
198 | } | 198 | return null; |
199 | } | 199 | } |
200 | } | 200 | |
201 | 201 | public InventoryItemBase FindAsset(UUID assetID) | |
202 | return null; | 202 | { |
203 | } | 203 | lock (Items) |
204 | 204 | { | |
205 | public InventoryItemBase FindAsset(UUID assetID) | 205 | foreach (InventoryItemBase item in Items.Values) |
206 | { | 206 | { |
207 | lock (Items) | 207 | if (item.AssetID == assetID) |
208 | { | 208 | return item; |
209 | foreach (InventoryItemBase item in Items.Values) | 209 | } |
210 | { | 210 | } |
211 | if (item.AssetID == assetID) | 211 | |
212 | return item; | 212 | lock (m_childFolders) |
213 | } | 213 | { |
214 | } | 214 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
215 | 215 | { | |
216 | lock (m_childFolders) | 216 | InventoryItemBase item = folder.FindAsset(assetID); |
217 | { | 217 | |
218 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 218 | if (item != null) |
219 | { | 219 | { |
220 | InventoryItemBase item = folder.FindAsset(assetID); | 220 | return item; |
221 | 221 | } | |
222 | if (item != null) | 222 | } |
223 | { | 223 | } |
224 | return item; | 224 | |
225 | } | 225 | return null; |
226 | } | 226 | } |
227 | } | 227 | |
228 | 228 | /// <summary> | |
229 | return null; | 229 | /// Deletes an item if it exists in this folder or any children |
230 | } | 230 | /// </summary> |
231 | 231 | /// <param name="folderID"></param> | |
232 | /// <summary> | 232 | /// <returns></returns> |
233 | /// Deletes an item if it exists in this folder or any children | 233 | public bool DeleteItem(UUID itemID) |
234 | /// </summary> | 234 | { |
235 | /// <param name="folderID"></param> | 235 | bool found = false; |
236 | /// <returns></returns> | 236 | |
237 | public bool DeleteItem(UUID itemID) | 237 | lock (Items) |
238 | { | 238 | { |
239 | bool found = false; | 239 | if (Items.ContainsKey(itemID)) |
240 | 240 | { | |
241 | lock (Items) | 241 | Items.Remove(itemID); |
242 | { | 242 | return true; |
243 | if (Items.ContainsKey(itemID)) | 243 | } |
244 | { | 244 | } |
245 | Items.Remove(itemID); | 245 | |
246 | return true; | 246 | lock (m_childFolders) |
247 | } | 247 | { |
248 | } | 248 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
249 | 249 | { | |
250 | lock (m_childFolders) | 250 | found = folder.DeleteItem(itemID); |
251 | { | 251 | |
252 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 252 | if (found == true) |
253 | { | 253 | { |
254 | found = folder.DeleteItem(itemID); | 254 | break; |
255 | 255 | } | |
256 | if (found == true) | 256 | } |
257 | { | 257 | } |
258 | break; | 258 | |
259 | } | 259 | return found; |
260 | } | 260 | } |
261 | } | 261 | |
262 | 262 | /// <summary> | |
263 | return found; | 263 | /// Returns the folder requested if it is this folder or is a descendent of this folder. The search is depth |
264 | } | 264 | /// first. |
265 | 265 | /// </summary> | |
266 | /// <summary> | 266 | /// <returns>The requested folder if it exists, null if it does not.</returns> |
267 | /// Returns the folder requested if it is this folder or is a descendent of this folder. The search is depth | 267 | public InventoryFolderImpl FindFolder(UUID folderID) |
268 | /// first. | 268 | { |
269 | /// </summary> | 269 | if (folderID == ID) |
270 | /// <returns>The requested folder if it exists, null if it does not.</returns> | 270 | return this; |
271 | public InventoryFolderImpl FindFolder(UUID folderID) | 271 | |
272 | { | 272 | lock (m_childFolders) |
273 | if (folderID == ID) | 273 | { |
274 | return this; | 274 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
275 | 275 | { | |
276 | lock (m_childFolders) | 276 | InventoryFolderImpl returnFolder = folder.FindFolder(folderID); |
277 | { | 277 | |
278 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 278 | if (returnFolder != null) |
279 | { | 279 | return returnFolder; |
280 | InventoryFolderImpl returnFolder = folder.FindFolder(folderID); | 280 | } |
281 | 281 | } | |
282 | if (returnFolder != null) | 282 | |
283 | return returnFolder; | 283 | return null; |
284 | } | 284 | } |
285 | } | 285 | |
286 | 286 | /// <summary> | |
287 | return null; | 287 | /// Look through all child subfolders for a folder marked as one for a particular asset type, and return it. |
288 | } | 288 | /// </summary> |
289 | 289 | /// <param name="type"></param> | |
290 | /// <summary> | 290 | /// <returns>Returns null if no such folder is found</returns> |
291 | /// Look through all child subfolders for a folder marked as one for a particular asset type, and return it. | 291 | public InventoryFolderImpl FindFolderForType(int type) |
292 | /// </summary> | 292 | { |
293 | /// <param name="type"></param> | 293 | lock (m_childFolders) |
294 | /// <returns>Returns null if no such folder is found</returns> | 294 | { |
295 | public InventoryFolderImpl FindFolderForType(int type) | 295 | foreach (InventoryFolderImpl f in m_childFolders.Values) |
296 | { | 296 | { |
297 | lock (m_childFolders) | 297 | if (f.Type == type) |
298 | { | 298 | return f; |
299 | foreach (InventoryFolderImpl f in m_childFolders.Values) | 299 | } |
300 | { | 300 | } |
301 | if (f.Type == type) | 301 | |
302 | return f; | 302 | return null; |
303 | } | 303 | } |
304 | } | 304 | |
305 | 305 | /// <summary> | |
306 | return null; | 306 | /// Find a folder given a PATH_DELIMITER delimited path starting from this folder |
307 | } | 307 | /// </summary> |
308 | 308 | /// | |
309 | /// <summary> | 309 | /// This method does not handle paths that contain multiple delimitors |
310 | /// Find a folder given a PATH_DELIMITER delimited path starting from this folder | 310 | /// |
311 | /// </summary> | 311 | /// FIXME: We do not yet handle situations where folders have the same name. We could handle this by some |
312 | /// | 312 | /// XPath like expression |
313 | /// This method does not handle paths that contain multiple delimitors | 313 | /// |
314 | /// | 314 | /// FIXME: Delimitors which occur in names themselves are not currently escapable. |
315 | /// FIXME: We do not yet handle situations where folders have the same name. We could handle this by some | 315 | /// |
316 | /// XPath like expression | 316 | /// <param name="path"> |
317 | /// | 317 | /// The path to the required folder. |
318 | /// FIXME: Delimitors which occur in names themselves are not currently escapable. | 318 | /// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned. |
319 | /// | 319 | /// </param> |
320 | /// <param name="path"> | 320 | /// <returns>null if the folder is not found</returns> |
321 | /// The path to the required folder. | 321 | public InventoryFolderImpl FindFolderByPath(string path) |
322 | /// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned. | 322 | { |
323 | /// </param> | 323 | if (path == string.Empty) |
324 | /// <returns>null if the folder is not found</returns> | 324 | return this; |
325 | public InventoryFolderImpl FindFolderByPath(string path) | 325 | |
326 | { | 326 | path = path.Trim(); |
327 | if (path == string.Empty) | 327 | |
328 | return this; | 328 | if (path == PATH_DELIMITER) |
329 | 329 | return this; | |
330 | path = path.Trim(); | 330 | |
331 | 331 | string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None); | |
332 | if (path == PATH_DELIMITER) | 332 | |
333 | return this; | 333 | lock (m_childFolders) |
334 | 334 | { | |
335 | string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None); | 335 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
336 | 336 | { | |
337 | lock (m_childFolders) | 337 | if (folder.Name == components[0]) |
338 | { | 338 | if (components.Length > 1) |
339 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 339 | return folder.FindFolderByPath(components[1]); |
340 | { | 340 | else |
341 | if (folder.Name == components[0]) | 341 | return folder; |
342 | if (components.Length > 1) | 342 | } |
343 | return folder.FindFolderByPath(components[1]); | 343 | } |
344 | else | 344 | |
345 | return folder; | 345 | // We didn't find a folder with the given name |
346 | } | 346 | return null; |
347 | } | 347 | } |
348 | 348 | ||
349 | // We didn't find a folder with the given name | 349 | /// <summary> |
350 | return null; | 350 | /// Find an item given a PATH_DELIMITOR delimited path starting from this folder. |
351 | } | 351 | /// |
352 | 352 | /// This method does not handle paths that contain multiple delimitors | |
353 | /// <summary> | 353 | /// |
354 | /// Find an item given a PATH_DELIMITOR delimited path starting from this folder. | 354 | /// FIXME: We do not yet handle situations where folders or items have the same name. We could handle this by some |
355 | /// | 355 | /// XPath like expression |
356 | /// This method does not handle paths that contain multiple delimitors | 356 | /// |
357 | /// | 357 | /// FIXME: Delimitors which occur in names themselves are not currently escapable. |
358 | /// FIXME: We do not yet handle situations where folders or items have the same name. We could handle this by some | 358 | /// </summary> |
359 | /// XPath like expression | 359 | /// <param name="path"> |
360 | /// | 360 | /// The path to the required item. |
361 | /// FIXME: Delimitors which occur in names themselves are not currently escapable. | 361 | /// </param> |
362 | /// </summary> | 362 | /// <returns>null if the item is not found</returns> |
363 | /// <param name="path"> | 363 | public InventoryItemBase FindItemByPath(string path) |
364 | /// The path to the required item. | 364 | { |
365 | /// </param> | 365 | string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None); |
366 | /// <returns>null if the item is not found</returns> | 366 | |
367 | public InventoryItemBase FindItemByPath(string path) | 367 | if (components.Length == 1) |
368 | { | 368 | { |
369 | string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None); | 369 | lock (Items) |
370 | 370 | { | |
371 | if (components.Length == 1) | 371 | foreach (InventoryItemBase item in Items.Values) |
372 | { | 372 | { |
373 | lock (Items) | 373 | if (item.Name == components[0]) |
374 | { | 374 | return item; |
375 | foreach (InventoryItemBase item in Items.Values) | 375 | } |
376 | { | 376 | } |
377 | if (item.Name == components[0]) | 377 | } |
378 | return item; | 378 | else |
379 | } | 379 | { |
380 | } | 380 | lock (m_childFolders) |
381 | } | 381 | { |
382 | else | 382 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
383 | { | 383 | { |
384 | lock (m_childFolders) | 384 | if (folder.Name == components[0]) |
385 | { | 385 | return folder.FindItemByPath(components[1]); |
386 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 386 | } |
387 | { | 387 | } |
388 | if (folder.Name == components[0]) | 388 | } |
389 | return folder.FindItemByPath(components[1]); | 389 | |
390 | } | 390 | // We didn't find an item or intermediate folder with the given name |
391 | } | 391 | return null; |
392 | } | 392 | } |
393 | 393 | ||
394 | // We didn't find an item or intermediate folder with the given name | 394 | /// <summary> |
395 | return null; | 395 | /// Return a copy of the list of child items in this folder. The items themselves are the originals. |
396 | } | 396 | /// </summary> |
397 | 397 | public List<InventoryItemBase> RequestListOfItems() | |
398 | /// <summary> | 398 | { |
399 | /// Return a copy of the list of child items in this folder. The items themselves are the originals. | 399 | List<InventoryItemBase> itemList = new List<InventoryItemBase>(); |
400 | /// </summary> | 400 | |
401 | public List<InventoryItemBase> RequestListOfItems() | 401 | lock (Items) |
402 | { | 402 | { |
403 | List<InventoryItemBase> itemList = new List<InventoryItemBase>(); | 403 | foreach (InventoryItemBase item in Items.Values) |
404 | 404 | { | |
405 | lock (Items) | 405 | itemList.Add(item); |
406 | { | 406 | } |
407 | foreach (InventoryItemBase item in Items.Values) | 407 | } |
408 | { | 408 | |
409 | itemList.Add(item); | 409 | //m_log.DebugFormat("[INVENTORY FOLDER IMPL]: Found {0} items", itemList.Count); |
410 | } | 410 | |
411 | } | 411 | return itemList; |
412 | 412 | } | |
413 | //m_log.DebugFormat("[INVENTORY FOLDER IMPL]: Found {0} items", itemList.Count); | 413 | |
414 | 414 | /// <summary> | |
415 | return itemList; | 415 | /// Return a copy of the list of child folders in this folder. The folders themselves are the originals. |
416 | } | 416 | /// </summary> |
417 | 417 | public List<InventoryFolderBase> RequestListOfFolders() | |
418 | /// <summary> | 418 | { |
419 | /// Return a copy of the list of child folders in this folder. The folders themselves are the originals. | 419 | List<InventoryFolderBase> folderList = new List<InventoryFolderBase>(); |
420 | /// </summary> | 420 | |
421 | public List<InventoryFolderBase> RequestListOfFolders() | 421 | lock (m_childFolders) |
422 | { | 422 | { |
423 | List<InventoryFolderBase> folderList = new List<InventoryFolderBase>(); | 423 | foreach (InventoryFolderBase folder in m_childFolders.Values) |
424 | 424 | { | |
425 | lock (m_childFolders) | 425 | folderList.Add(folder); |
426 | { | 426 | } |
427 | foreach (InventoryFolderBase folder in m_childFolders.Values) | 427 | } |
428 | { | 428 | |
429 | folderList.Add(folder); | 429 | return folderList; |
430 | } | 430 | } |
431 | } | 431 | |
432 | 432 | public List<InventoryFolderImpl> RequestListOfFolderImpls() | |
433 | return folderList; | 433 | { |
434 | } | 434 | List<InventoryFolderImpl> folderList = new List<InventoryFolderImpl>(); |
435 | 435 | ||
436 | public List<InventoryFolderImpl> RequestListOfFolderImpls() | 436 | lock (m_childFolders) |
437 | { | 437 | { |
438 | List<InventoryFolderImpl> folderList = new List<InventoryFolderImpl>(); | 438 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
439 | 439 | { | |
440 | lock (m_childFolders) | 440 | folderList.Add(folder); |
441 | { | 441 | } |
442 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 442 | } |
443 | { | 443 | |
444 | folderList.Add(folder); | 444 | return folderList; |
445 | } | 445 | } |
446 | } | 446 | |
447 | 447 | /// <value> | |
448 | return folderList; | 448 | /// The total number of items in this folder and in the immediate child folders (though not from other |
449 | } | 449 | /// descendants). |
450 | 450 | /// </value> | |
451 | /// <value> | 451 | public int TotalCount |
452 | /// The total number of items in this folder and in the immediate child folders (though not from other | 452 | { |
453 | /// descendants). | 453 | get |
454 | /// </value> | 454 | { |
455 | public int TotalCount | 455 | int total = Items.Count; |
456 | { | 456 | |
457 | get | 457 | foreach (InventoryFolderImpl folder in m_childFolders.Values) |
458 | { | 458 | { |
459 | int total = Items.Count; | 459 | total = total + folder.TotalCount; |
460 | 460 | } | |
461 | foreach (InventoryFolderImpl folder in m_childFolders.Values) | 461 | |
462 | { | 462 | return total; |
463 | total = total + folder.TotalCount; | 463 | } |
464 | } | 464 | } |
465 | 465 | } | |
466 | return total; | 466 | } |
467 | } | ||
468 | } | ||
469 | } | ||
470 | } | ||