OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update svn properties.

trunk
Jeff Ames 2009-07-01 10:26:43 +00:00
parent aae94a8c80
commit 3f2fba610e
5 changed files with 330 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
OpenSim/Region/OptionalModules/Scripting/Minimodule/Interfaces/IInventoryItem.cs
View File

@ -1,16 +1,16 @@
using System; using System;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Region.OptionalModules.Scripting.Minimodule namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
{ {
/// <summary> /// <summary>
/// This implements the methods needed to operate on individual inventory items. /// This implements the methods needed to operate on individual inventory items.
/// </summary> /// </summary>
public interface IInventoryItem public interface IInventoryItem
{ {
int Type { get; } int Type { get; }
UUID AssetID { get; } UUID AssetID { get; }
T RetreiveAsset<T>() where T : OpenMetaverse.Asset, new(); T RetreiveAsset<T>() where T : OpenMetaverse.Asset, new();
} }
} }

144
OpenSim/Region/OptionalModules/Scripting/Minimodule/InventoryItem.cs
View File

@ -1,72 +1,72 @@
using System; using System;
using System.Text; using System.Text;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Region.Framework.Scenes; using OpenSim.Region.Framework.Scenes;
//using OpenSim.Services.AssetService; //using OpenSim.Services.AssetService;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Region.OptionalModules.Scripting.Minimodule namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
{ {
public class InventoryItem : IInventoryItem public class InventoryItem : IInventoryItem
{ {
TaskInventoryItem m_privateItem; TaskInventoryItem m_privateItem;
Scene m_rootSceene; Scene m_rootSceene;
public InventoryItem(Scene rootScene, TaskInventoryItem internalItem) public InventoryItem(Scene rootScene, TaskInventoryItem internalItem)
{ {
m_rootSceene = rootScene; m_rootSceene = rootScene;
m_privateItem = internalItem; m_privateItem = internalItem;
} }
// Marked internal, to prevent scripts from accessing the internal type // Marked internal, to prevent scripts from accessing the internal type
internal TaskInventoryItem ToTaskInventoryItem() internal TaskInventoryItem ToTaskInventoryItem()
{ {
return m_privateItem; return m_privateItem;
} }
/// <summary> /// <summary>
/// This will attempt to convert from an IInventoryItem to an InventoryItem object /// This will attempt to convert from an IInventoryItem to an InventoryItem object
/// </summary> /// </summary>
/// <description> /// <description>
/// In order for this to work the object which implements IInventoryItem must inherit from InventoryItem, otherwise /// In order for this to work the object which implements IInventoryItem must inherit from InventoryItem, otherwise
/// an exception is thrown. /// an exception is thrown.
/// </description> /// </description>
/// <param name="i"> /// <param name="i">
/// The interface to upcast <see cref="IInventoryItem"/> /// The interface to upcast <see cref="IInventoryItem"/>
/// </param> /// </param>
/// <returns> /// <returns>
/// The object backing the interface implementation <see cref="InventoryItem"/> /// The object backing the interface implementation <see cref="InventoryItem"/>
/// </returns> /// </returns>
internal static InventoryItem FromInterface(IInventoryItem i) internal static InventoryItem FromInterface(IInventoryItem i)
{ {
if(typeof(InventoryItem).IsAssignableFrom(i.GetType())) if(typeof(InventoryItem).IsAssignableFrom(i.GetType()))
{ {
return (InventoryItem)i; return (InventoryItem)i;
} }
else else
{ {
throw new ApplicationException("[MRM] There is no legal conversion from IInventoryItem to InventoryItem"); throw new ApplicationException("[MRM] There is no legal conversion from IInventoryItem to InventoryItem");
} }
} }
public int Type { get { return m_privateItem.Type; } } public int Type { get { return m_privateItem.Type; } }
public UUID AssetID { get { return m_privateItem.AssetID; } } public UUID AssetID { get { return m_privateItem.AssetID; } }
public T RetreiveAsset<T>() where T : OpenMetaverse.Asset, new() public T RetreiveAsset<T>() where T : OpenMetaverse.Asset, new()
{ {
AssetBase a = m_rootSceene.AssetService.Get(AssetID.ToString()); AssetBase a = m_rootSceene.AssetService.Get(AssetID.ToString());
T result = new T(); T result = new T();
if((sbyte)result.AssetType != a.Type) if((sbyte)result.AssetType != a.Type)
throw new ApplicationException("[MRM] The supplied asset class does not match the found asset"); throw new ApplicationException("[MRM] The supplied asset class does not match the found asset");
result.AssetData = a.Data; result.AssetData = a.Data;
result.Decode(); result.Decode();
return result; return result;
} }
} }
} }

34
OpenSim/Region/OptionalModules/Scripting/Minimodule/Object/IObjectInventory.cs
View File

@ -1,17 +1,17 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Region.OptionalModules.Scripting.Minimodule.Object namespace OpenSim.Region.OptionalModules.Scripting.Minimodule.Object
{ {
/// <summary> /// <summary>
/// This implements the methods neccesary to operate on the inventory of an object /// This implements the methods neccesary to operate on the inventory of an object
/// </summary> /// </summary>
public interface IObjectInventory : IDictionary<UUID, IInventoryItem> public interface IObjectInventory : IDictionary<UUID, IInventoryItem>
{ {
IInventoryItem this[string name] { get; } IInventoryItem this[string name] { get; }
} }
} }

380
OpenSim/Region/OptionalModules/Scripting/Minimodule/SOPObjectInventory.cs
View File

@ -1,190 +1,190 @@
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Region.Framework.Scenes; using OpenSim.Region.Framework.Scenes;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Region.OptionalModules.Scripting.Minimodule.Object namespace OpenSim.Region.OptionalModules.Scripting.Minimodule.Object
{ {
public class SOPObjectInventory : IObjectInventory public class SOPObjectInventory : IObjectInventory
{ {
TaskInventoryDictionary m_privateInventory; /// OpenSim's task inventory TaskInventoryDictionary m_privateInventory; /// OpenSim's task inventory
Dictionary<UUID, IInventoryItem> m_publicInventory; /// MRM's inventory Dictionary<UUID, IInventoryItem> m_publicInventory; /// MRM's inventory
Scene m_rootScene; Scene m_rootScene;
public SOPObjectInventory(Scene rootScene, TaskInventoryDictionary taskInventory) public SOPObjectInventory(Scene rootScene, TaskInventoryDictionary taskInventory)
{ {
m_rootScene = rootScene; m_rootScene = rootScene;
m_privateInventory = taskInventory; m_privateInventory = taskInventory;
m_publicInventory = new Dictionary<UUID, IInventoryItem>(); m_publicInventory = new Dictionary<UUID, IInventoryItem>();
} }
/// <summary> /// <summary>
/// Fully populate the public dictionary with the contents of the private dictionary /// Fully populate the public dictionary with the contents of the private dictionary
/// </summary> /// </summary>
/// <description> /// <description>
/// This will only convert those items which hasn't already been converted. ensuring that /// This will only convert those items which hasn't already been converted. ensuring that
/// no items are converted twice, and that any references already in use are maintained. /// no items are converted twice, and that any references already in use are maintained.
/// </description> /// </description>
private void SynchronizeDictionaries() private void SynchronizeDictionaries()
{ {
foreach(TaskInventoryItem privateItem in m_privateInventory.Values) foreach(TaskInventoryItem privateItem in m_privateInventory.Values)
if(!m_publicInventory.ContainsKey(privateItem.ItemID)) if(!m_publicInventory.ContainsKey(privateItem.ItemID))
m_publicInventory.Add(privateItem.ItemID, new InventoryItem(m_rootScene, privateItem)); m_publicInventory.Add(privateItem.ItemID, new InventoryItem(m_rootScene, privateItem));
} }
#region IDictionary<UUID, IInventoryItem> implementation #region IDictionary<UUID, IInventoryItem> implementation
public void Add (UUID key, IInventoryItem value) public void Add (UUID key, IInventoryItem value)
{ {
m_publicInventory.Add(key, value); m_publicInventory.Add(key, value);
m_privateInventory.Add(key, InventoryItem.FromInterface(value).ToTaskInventoryItem()); m_privateInventory.Add(key, InventoryItem.FromInterface(value).ToTaskInventoryItem());
} }
public bool ContainsKey (UUID key) public bool ContainsKey (UUID key)
{ {
return m_privateInventory.ContainsKey(key); return m_privateInventory.ContainsKey(key);
} }
public bool Remove (UUID key) public bool Remove (UUID key)
{ {
m_publicInventory.Remove(key); m_publicInventory.Remove(key);
return m_privateInventory.Remove(key); return m_privateInventory.Remove(key);
} }
public bool TryGetValue (UUID key, out IInventoryItem value) public bool TryGetValue (UUID key, out IInventoryItem value)
{ {
value = null; value = null;
bool result = false; bool result = false;
if(!m_publicInventory.TryGetValue(key, out value)) if(!m_publicInventory.TryGetValue(key, out value))
{ {
// wasn't found in the public inventory // wasn't found in the public inventory
TaskInventoryItem privateItem; TaskInventoryItem privateItem;
result = m_privateInventory.TryGetValue(key, out privateItem); result = m_privateInventory.TryGetValue(key, out privateItem);
if(result) if(result)
{ {
value = new InventoryItem(m_rootScene, privateItem); value = new InventoryItem(m_rootScene, privateItem);
m_publicInventory.Add(key, value); // add item, so we don't convert again m_publicInventory.Add(key, value); // add item, so we don't convert again
} }
} else } else
return true; return true;
return result; return result;
} }
public ICollection<UUID> Keys { public ICollection<UUID> Keys {
get { get {
return m_privateInventory.Keys; return m_privateInventory.Keys;
} }
} }
public ICollection<IInventoryItem> Values { public ICollection<IInventoryItem> Values {
get { get {
SynchronizeDictionaries(); SynchronizeDictionaries();
return m_publicInventory.Values; return m_publicInventory.Values;
} }
} }
#endregion #endregion
#region IEnumerable<KeyValuePair<UUID, IInventoryItem>> implementation #region IEnumerable<KeyValuePair<UUID, IInventoryItem>> implementation
public IEnumerator<KeyValuePair<UUID, IInventoryItem>> GetEnumerator () public IEnumerator<KeyValuePair<UUID, IInventoryItem>> GetEnumerator ()
{ {
SynchronizeDictionaries(); SynchronizeDictionaries();
return m_publicInventory.GetEnumerator(); return m_publicInventory.GetEnumerator();
} }
#endregion #endregion
#region IEnumerable implementation #region IEnumerable implementation
IEnumerator IEnumerable.GetEnumerator () IEnumerator IEnumerable.GetEnumerator ()
{ {
SynchronizeDictionaries(); SynchronizeDictionaries();
return m_publicInventory.GetEnumerator(); return m_publicInventory.GetEnumerator();
} }
#endregion #endregion
#region ICollection<KeyValuePair<UUID, IInventoryItem>> implementation #region ICollection<KeyValuePair<UUID, IInventoryItem>> implementation
public void Add (KeyValuePair<UUID, IInventoryItem> item) public void Add (KeyValuePair<UUID, IInventoryItem> item)
{ {
Add(item.Key, item.Value); Add(item.Key, item.Value);
} }
public void Clear () public void Clear ()
{ {
m_publicInventory.Clear(); m_publicInventory.Clear();
m_privateInventory.Clear(); m_privateInventory.Clear();
} }
public bool Contains (KeyValuePair<UUID, IInventoryItem> item) public bool Contains (KeyValuePair<UUID, IInventoryItem> item)
{ {
return m_privateInventory.ContainsKey(item.Key); return m_privateInventory.ContainsKey(item.Key);
} }
public void CopyTo (KeyValuePair<UUID, IInventoryItem>[] array, int arrayIndex) public void CopyTo (KeyValuePair<UUID, IInventoryItem>[] array, int arrayIndex)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
public bool Remove (KeyValuePair<UUID, IInventoryItem> item) public bool Remove (KeyValuePair<UUID, IInventoryItem> item)
{ {
return Remove(item.Key); return Remove(item.Key);
} }
public int Count { public int Count {
get { get {
return m_privateInventory.Count; return m_privateInventory.Count;
} }
} }
public bool IsReadOnly { public bool IsReadOnly {
get { get {
return false; return false;
} }
} }
#endregion #endregion
#region Explicit implementations #region Explicit implementations
IInventoryItem System.Collections.Generic.IDictionary<UUID, IInventoryItem>.this[UUID key] IInventoryItem System.Collections.Generic.IDictionary<UUID, IInventoryItem>.this[UUID key]
{ {
get { get {
IInventoryItem result; IInventoryItem result;
if(TryGetValue(key, out result)) if(TryGetValue(key, out result))
return result; return result;
else else
throw new KeyNotFoundException("[MRM] The requrested item ID could not be found"); throw new KeyNotFoundException("[MRM] The requrested item ID could not be found");
} }
set { set {
m_publicInventory[key] = value; m_publicInventory[key] = value;
m_privateInventory[key] = InventoryItem.FromInterface(value).ToTaskInventoryItem(); m_privateInventory[key] = InventoryItem.FromInterface(value).ToTaskInventoryItem();
} }
} }
void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<UUID, IInventoryItem>>.CopyTo(System.Collections.Generic.KeyValuePair<UUID,IInventoryItem>[] array, int offset) void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<UUID, IInventoryItem>>.CopyTo(System.Collections.Generic.KeyValuePair<UUID,IInventoryItem>[] array, int offset)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
#endregion #endregion
public IInventoryItem this[string name] public IInventoryItem this[string name]
{ {
get { get {
foreach(TaskInventoryItem i in m_privateInventory.Values) foreach(TaskInventoryItem i in m_privateInventory.Values)
if(i.Name == name) if(i.Name == name)
{ {
if(!m_publicInventory.ContainsKey(i.ItemID)) if(!m_publicInventory.ContainsKey(i.ItemID))
m_publicInventory.Add(i.ItemID, new InventoryItem(m_rootScene, i)); m_publicInventory.Add(i.ItemID, new InventoryItem(m_rootScene, i));
return m_publicInventory[i.ItemID]; return m_publicInventory[i.ItemID];
} }
throw new KeyNotFoundException(); throw new KeyNotFoundException();
} }
} }
} }
} }

70
OpenSim/Region/OptionalModules/Scripting/Minimodule/SPAvatarAttachment.cs
View File

@ -1,35 +1,35 @@
using System; using System;
using OpenMetaverse; using OpenMetaverse;
using OpenSim.Region.Framework.Scenes; using OpenSim.Region.Framework.Scenes;
namespace OpenSim.Region.OptionalModules.Scripting.Minimodule namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
{ {
public class SPAvatarAttachment : IAvatarAttachment public class SPAvatarAttachment : IAvatarAttachment
{ {
private readonly Scene m_rootScene; private readonly Scene m_rootScene;
private readonly IAvatar m_parent; private readonly IAvatar m_parent;
private readonly int m_location; private readonly int m_location;
private readonly UUID m_itemId; private readonly UUID m_itemId;
private readonly UUID m_assetId; private readonly UUID m_assetId;
public SPAvatarAttachment(Scene rootScene, IAvatar self, int location, UUID itemId, UUID assetId) public SPAvatarAttachment(Scene rootScene, IAvatar self, int location, UUID itemId, UUID assetId)
{ {
m_rootScene = rootScene; m_rootScene = rootScene;
m_parent = self; m_parent = self;
m_location = location; m_location = location;
m_itemId = itemId; m_itemId = itemId;
m_assetId = assetId; m_assetId = assetId;
} }
public int Location { get { return m_location; } } public int Location { get { return m_location; } }
public IObject Asset public IObject Asset
{ {
get get
{ {
return new SOPObject(m_rootScene, m_rootScene.GetSceneObjectPart(m_assetId).LocalId); return new SOPObject(m_rootScene, m_rootScene.GetSceneObjectPart(m_assetId).LocalId);
} }
} }
} }
} }