public void FireEvent(IDataIdentifier data, Object[] args)
{
if (HasPendingTransaction())
{
MyPendingEvents.Add(new EventFire(data, args));
}
else
{
foreach (EventSubscription eventSubscription in (ArrayList)(MyEventSubscriptions.Clone()))
{
// Compare if fired data object is same as
// subscribed data object.
// Try to compare with the IDataIdentity interface if possible.
// The IDataIdentity interface works independet
// from changes of the identifier.
if (((data is IDataIdentity) &&
(eventSubscription.GetData() is IDataIdentity) &&
(AreEqual((IDataIdentity)data, (IDataIdentity)(eventSubscription.GetData())))) ||
AreEqual(data, eventSubscription.GetData()))
{
// Notify subscriber of event.
eventSubscription.GetDelegate().DynamicInvoke(args);
}
}
}
}
internal void SetValue <V>(IDataIdentifier dataIdentifier, V val)
{
object oVal;
if (this._data.TryGetValue(dataIdentifier, out oVal))
{
if (oVal is V)
{
if (Equals(val, default(V)))
{
this._data.Remove(dataIdentifier);
}
else
{
this._data[dataIdentifier] = val;
}
}
else
{
Debug.LogError("Setting different value type for identifier " + dataIdentifier);
}
}
else
{
this._data.Add(dataIdentifier, val);
}
}
public void Store <T>(IDataIdentifier id, T value)
{
if (Contains(id) && !Get <T>(id).Equals(value))
{
changes.OnNext(id);
}
values[id] = value;
}
public System.Xml.XmlDocument OpenData(IDataIdentifier id)
{
//TODO - Review this later.
string nullDataFilter = dataXPathTemplate[NullFilter].Template;
string query = nullDataFilter.Replace(SelectionPlaceholder, ((GuidIdentifier)id).ID.ToString());
return(GetXmlDocument(GetXml(query)));
}
public System.Xml.XmlDocument OpenData(IDataIdentifier id, IDataFilter filter)
{
//TODO - Review this later.
string dataFilterTemplate = dataXPathTemplate[filter.TemplateName].Template;
string selection = dataFilterTemplate.Replace(SelectionPlaceholder, ((GuidIdentifier)id).ID.ToString());
return(GetXmlDocument(GetXml(filter.GetFilterExpression(selection))));
}
public DataUpdateLock(Guid id, IDataIdentifier data, DateTime expiresAt)
{
this.id = id;
this.data = data;
this.expiresAt = expiresAt;
expiryTimer = new Timer();
expiryTimer.Interval = (expiresAt - DateTime.Now).Milliseconds;
expiryTimer.Enabled = true;
expiryTimer.Elapsed += new ElapsedEventHandler(expiryTimer_Elapsed);
}
public bool HasTileData(Vector2Int tile, IDataIdentifier dataIdentifier)
{
TileData tileData;
if (this._tiles.TryGetValue(tile, out tileData))
{
return(tileData.HasValue(dataIdentifier));
}
return(false);
}
public void Setup()
{
datastore = new StringObjectDatastore();
observableDatastore = (StringObjectDatastore)datastore;
serializableDatastore = (StringObjectDatastore)datastore;
id1 = new StringIdentifier("Key1");
id2 = new StringIdentifier("Key2");
id3 = new StringIdentifier("Key3");
}
public void RemoveEventSubscription(IDataIdentifier data, Delegate dataDelegate)
{
foreach (EventSubscription eventSubscription in MyEventSubscriptions)
{
if (eventSubscription.GetDelegate() == dataDelegate)
{
MyEventSubscriptions.Remove(eventSubscription);
break;
}
}
}
public IEnumerable <V> GetAllTilesData <V>(IDataIdentifier dataIdentifier)
{
V data;
foreach (var tileData in this._tiles.Values)
{
if (tileData.TryGetValue(dataIdentifier, out data))
{
yield return(data);
}
}
}
internal bool TryGetValue <V>(IDataIdentifier dataIdentifier, out V val)
{
object oVal;
if (this._data.TryGetValue(dataIdentifier, out oVal) &&
oVal is V)
{
val = (V)oVal;
return(true);
}
val = default(V);
return(false);
}
public DataUpdateLock GetUpdateLock(IDataIdentifier id)
{
lock (locked)
{
if (locked.Contains(id))
{
return(null);
}
DataUpdateLock updateLock = new DataUpdateLock(Guid.NewGuid(), id, DateTime.Now.AddMinutes(1));
updateLocks.Add(updateLock.Id, updateLock);
locked.Add(id);
updateLock.OnLockExpired += new LockExpiryEvent(OnLockExpired);
return(updateLock);
}
}
public bool GetTileData <V>(Vector2Int tile, IDataIdentifier dataIdentifier, out V data)
{
TileData tileData;
if (this._tiles.TryGetValue(tile, out tileData))
{
if (tileData.TryGetValue(dataIdentifier, out data))
{
return(data != null);
}
}
else
{
data = default(V);
}
return(false);
}
public void UnsetTileData <V>(Vector2Int tile, IDataIdentifier dataIdentifier)
{
TileData tileData;
if (this._tiles.TryGetValue(tile, out tileData))
{
if (tileData.UnsetValue <V>(dataIdentifier))
{
if (!tileData.HasValues())
{
this._tiles.Remove(tile);
tileData.Clear(true);
AutoPool <TileData> .Dispose(tileData);
}
}
}
}
public bool HasTileData <V>(Vector2Int tile, IDataIdentifier dataIdentifier, V search)
{
V data;
TileData tileData;
if (this._tiles.TryGetValue(tile, out tileData))
{
if (tileData.TryGetValue(dataIdentifier, out data))
{
return(Object.Equals(data, search));
}
}
else
{
data = default(V);
}
return(false);
}
public void SetTileData <V>(Vector2Int tile, IDataIdentifier dataIdentifier, V data)
{
TileData tileData;
if (!this._tiles.TryGetValue(tile, out tileData))
{
if (!Equals(default(V), data))
{
tileData = AutoPool <TileData> .Create();
this._tiles.Add(tile, tileData);
}
else
{
return;
}
}
tileData.SetValue(dataIdentifier, data);
}
public static Boolean AreEqual(IDataIdentifier object1, IDataIdentifier object2)
{
// Check referenses.
if (IsNull(object1) && IsNull(object2))
{
return(true);
}
if (IsNull(object1) || IsNull(object2))
{
return(false);
}
// Check type.
if (object1.GetDataType() != object2.GetDataType())
{
return(false);
}
// Check identifier.
return(AreEqual(object1.GetIdentifier(), object2.GetIdentifier()));
}
public static Boolean AreNotEqual(IDataIdentifier object1, IDataIdentifier object2)
{
return(!AreEqual(object1, object2));
}
internal bool UnsetValue <V>(IDataIdentifier dataIdentifier)
{
return(this._data.Remove(dataIdentifier));
}
public IEnumerable <V> GetMatchingTilesData <V>(Vector2Int tileFrom, Vector2Int tileTo, IDataIdentifier dataIdentifier)
{
V data;
Vector2Int gridPos = new Vector2Int();
int xMin = Mathf.Min(tileFrom.x, tileTo.x);
int xMax = Mathf.Max(tileFrom.x, tileTo.x);
int yMin = Mathf.Min(tileFrom.y, tileTo.y);
int yMax = Mathf.Max(tileFrom.y, tileTo.y);
for (int x = xMin; x <= xMax; ++x)
{
for (int y = yMin; y <= yMax; ++y)
{
gridPos.Set(x, y);
if (GetTileData(gridPos, dataIdentifier, out data))
{
yield return(data);
}
}
}
}
public void UnsetTileData <V>(Vector2Int tileFrom, Vector2Int tileTo, IDataIdentifier dataIdentifier)
{
ForEach(tileFrom, tileTo, this.UnsetTileData <V>, dataIdentifier);
}
public void UpdateData(System.Xml.XmlDocument updatedData, IDataIdentifier id)
{
throw new NotImplementedException();
}
public bool HasTileData <V>(Vector2Int tileFrom, Vector2Int tileTo, IDataIdentifier dataIdentifier, V searchType, Match match = Match.Any)
{
if (match == Match.All)
{
return(All(tileFrom, tileTo, this.HasTileData, dataIdentifier, searchType));
}
else
{
return(Any(tileFrom, tileTo, this.HasTileData, dataIdentifier, searchType));
}
}
public static bool All <P>(Vector2Int tileFrom, Vector2Int tileTo, System.Func <Vector2Int, IDataIdentifier, P, bool> action, IDataIdentifier dataIdentifier, P param)
{
Vector2Int gridPos = new Vector2Int();
int xMin = Mathf.Min(tileFrom.x, tileTo.x);
int xMax = Mathf.Max(tileFrom.x, tileTo.x);
int yMin = Mathf.Min(tileFrom.y, tileTo.y);
int yMax = Mathf.Max(tileFrom.y, tileTo.y);
for (int x = xMin; x <= xMax; ++x)
{
for (int y = yMin; y <= yMax; ++y)
{
gridPos.Set(x, y);
if (!action(gridPos, dataIdentifier, param))
{
return(false);
}
}
}
return(true);
}
public static void ForEach <P>(Vector2Int tileFrom, Vector2Int tileTo, System.Action <Vector2Int, IDataIdentifier, P> action, IDataIdentifier dataIdentifier, P param)
{
Vector2Int gridPos = new Vector2Int();
int xMin = Mathf.Min(tileFrom.x, tileTo.x);
int xMax = Mathf.Max(tileFrom.x, tileTo.x);
int yMin = Mathf.Min(tileFrom.y, tileTo.y);
int yMax = Mathf.Max(tileFrom.y, tileTo.y);
for (int x = xMin; x <= xMax; ++x)
{
for (int y = yMin; y <= yMax; ++y)
{
gridPos.Set(x, y);
action(gridPos, dataIdentifier, param);
}
}
}
public XmlDocument OpenData(IDataIdentifier id, IDataFilter filter)
{
return(catalogSource.OpenData(id, filter));
}
public XmlDocument OpenData(IDataIdentifier id)
{
return(catalogSource.OpenData(id));
}
public void AddEventSubscription(IDataIdentifier data, Delegate dataDelegate)
{
MyEventSubscriptions.Add(new EventSubscription(data, dataDelegate));
}
public void SetTileData <V>(Vector2Int tileFrom, Vector2Int tileTo, IDataIdentifier dataIdentifier, V data)
{
ForEach(tileFrom, tileTo, this.SetTileData, dataIdentifier, data);
}
internal bool HasValue(IDataIdentifier dataIdentifier)
{
return(this._data.ContainsKey(dataIdentifier));
}
