diff options
author | diva | 2009-06-07 19:00:55 +0000 |
---|---|---|
committer | diva | 2009-06-07 19:00:55 +0000 |
commit | 1ad237a8a757a0e6074278aff76805d01abf0c0b (patch) | |
tree | e6a697dd113aeb90c7dd92ee4d07f278d7ebf8de /OpenSim/Framework | |
parent | Skip lone ident statments or for-loop assignments (diff) | |
download | opensim-SC_OLD-1ad237a8a757a0e6074278aff76805d01abf0c0b.zip opensim-SC_OLD-1ad237a8a757a0e6074278aff76805d01abf0c0b.tar.gz opensim-SC_OLD-1ad237a8a757a0e6074278aff76805d01abf0c0b.tar.bz2 opensim-SC_OLD-1ad237a8a757a0e6074278aff76805d01abf0c0b.tar.xz |
First draft of inventory service connectors, and service implementation. No handlers yet, this is just the OUT part for now. It's not active and nothing in the simulator uses this yet. Just checking it in to start sharing with others. There are a couple of interesting software design points that could use other devs opinions.
Hopefully I added all needed files.
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 | } | ||