public static T GetObject(string id)
{
if (id == null)
{
return(null);
}
if (UnifiedSystem.UseOmniBase)
{
lock (UnifiedSystem.OmniBase)
if (UnifiedSystem.OmniBase.ContainsKey(id))
{
IUnifiedIMObject obj = UnifiedSystem.OmniBase[id];
if (obj is T)
{
return((T)obj);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
else
{
return(Database.FirstOrDefault(x => x.ObjectID == id));
}
}
internal static void DeleteReferences(IUnifiedIMObject obj)
{
Type t = obj.GetType();
foreach (UnifiedIMReference rf in References)
{
DeleteReference(obj, rf);
}
}
//Internals
internal static void FixIndex(IUnifiedIMObject obj, Type t, string property, object oldValue)
{
if (Indexes.ContainsKey(t))
{
ObjectIndexer <IUnifiedIMObject> pIndexes = Indexes[t];
object cVal = Property.Get(obj, property) ?? null;
pIndexes.RemoveIndex(property, oldValue, obj);
pIndexes.AddIndex(property, cVal, obj);
}
}
internal static void DeleteIndexes(IUnifiedIMObject obj)
{
if (Indexes.ContainsKey(obj.DataType))
{
ObjectIndexer <IUnifiedIMObject> pIndexes = Indexes[obj.DataType];
foreach (string prop in pIndexes.Properties)
{
object cVal = Property.Get(obj, prop) ?? null;
pIndexes.RemoveIndex(prop, cVal, obj);
}
}
}
internal static void ResolveReferences(IUnifiedIMObject obj, Type type = null)
{
if (type == null)
{
type = obj.GetType();
}
if (TypeReferences.ContainsKey(type))
{
foreach (UnifiedIMReference reference in TypeReferences[type])
{
ResolveReference(obj, reference, type);
}
}
}
internal static void HandleObjectDeletion <T>(IUnifiedIMObject obj)
{
if (UnifiedSystem.AllowReferences)
{
UnifiedSystem.DeleteReferences(obj);
}
if (UnifiedSystem.UseOmniBase)
{
lock (UnifiedSystem.OmniBase)
UnifiedSystem.OmniBase.Remove(obj.ObjectID);
}
if (UnifiedSystem.AllowIndexes)
{
UnifiedSystem.DeleteIndexes(obj);
}
}
internal static void UpdateReference(UnifiedIMReference reference, IUnifiedIMObject host, IUnifiedIMObject target)
{
object hVal = reference.GetHostProperty(host);
object tVal = reference.GetTargetProperty(target);
if (Matches(reference, hVal, tVal))
{
if (typeof(IList).IsAssignableFrom(reference.SetPropertyType))
{
IList list = (IList)reference.GetReferenceProperty(host);
if (list == null)
{
throw new ArgumentException("Reference Lists should be initiated with an instance. And never be null");
}
//if (!list.Contains(target))
list.Add(target);
}
else
{
reference.SetReferenceProperty(host, target);
}
target.RefTo.Add(new KeyValuePair <UnifiedIMReference, IUnifiedIMObject>(reference, host));
}
else
{
if (typeof(IList).IsAssignableFrom(reference.SetPropertyType))
{
IList list = (IList)reference.GetReferenceProperty(host);
if (list == null)
{
throw new ArgumentException("Reference Lists should be initiated with an instance. And never be null");
}
//if (list.Contains(target))
list.Remove(target);
}
else
{
object curVal = reference.GetReferenceProperty(host);
if (curVal == target)
{
reference.SetReferenceProperty(host, null);
}
}
target.RefTo.RemoveAll(x => x.Key == reference && x.Value == host);
}
}
internal static void HandleObjectChange <T>(IUnifiedIMObject obj)
{
string key = obj.ObjectID;
Type t = typeof(T);
if (UnifiedSystem.AllowReferences || UnifiedSystem.AllowIndexes)
{
//Loop over Changes
foreach (KeyValuePair <string, UIMPropertyState> changeState in obj.PropertyStates)
{
object cVal = Property.Get(obj, changeState.Key) ?? null;
changeState.Value.HasChangedAndUpdate(cVal, (oldVal, newVal) =>
{
//Index Updating
if (AllowIndexes)
{
FixIndex(obj, t, changeState.Key, changeState.Value.LastState);
}
//Reference Updating
if (AllowReferences)
{
if (HostReferences.ContainsKey(t))
{
UnifiedIMReference hRefs = HostReferences[t].FirstOrDefault(x => x.HostProperty == changeState.Key);
if (hRefs != null)
{
DeleteReference(obj, hRefs);
ResolveReference(obj, hRefs, t);
}
}
if (TargetReferences.ContainsKey(t))
{
List <UnifiedIMReference> tRefs = TargetReferences[t].Where(x => x.TargetProperty == changeState.Key).ToList();
foreach (UnifiedIMReference reff in tRefs)
{
DeleteReference(obj, reff);
ResolveReference(obj, reff);
}
}
}
});
}
}
}
internal static void DeleteReference(IUnifiedIMObject obj, UnifiedIMReference rf)
{
lock (obj.RefTo)
{
if (rf.TargetType == obj.DataType)
{
foreach (KeyValuePair <UnifiedIMReference, IUnifiedIMObject> o in obj.RefTo)
{
if (o.Value.DataType == rf.HostType)
{
object sProperty = rf.GetReferenceProperty(o.Value);
if (typeof(IList).IsAssignableFrom(rf.SetPropertyType))
{
((IList)sProperty).Remove(obj);
}
else if (sProperty == obj)
{
rf.SetReferenceProperty(o.Value, null);
}
}
}
obj.RefTo.RemoveAll(x => x.Key == rf);
}
else if (rf.HostType == obj.DataType)
{
object sProperty = rf.GetReferenceProperty(obj);
if (typeof(IList).IsAssignableFrom(rf.SetPropertyType))
{
foreach (object o in ((IList)sProperty))
{
((IUnifiedIMObject)o).RefTo.RemoveAll(x => x.Key == rf && x.Value == obj);
}
((IList)sProperty).Clear();
}
else if (sProperty == obj)
{
rf.SetReferenceProperty(obj, null);
((IUnifiedIMObject)sProperty).RefTo.RemoveAll(x => x.Key == rf && x.Value == obj);
}
}
}
}
internal static void ResolveReference(IUnifiedIMObject obj, UnifiedIMReference reference, Type type = null)
{
if (type == null)
{
type = obj.GetType();
}
if (reference.TargetType == type)
{
if (UseOmniBase && reference.HostProperty == "ObjectID")
{
string od = (string)reference.GetTargetProperty(obj);
if (od != null)
{
bool hasKey = false;
IUnifiedIMObject omniObj = null;
lock (UnifiedSystem.OmniBase)
{
hasKey = UnifiedSystem.OmniBase.ContainsKey(od);
if (hasKey)
{
omniObj = OmniBase[od];
}
}
if (hasKey)
{
UpdateReference(reference, omniObj, obj);
}
}
}
else
{
if (AllowIndexes && Indexes.ContainsKey(reference.HostType) && Indexes[reference.HostType].HasTypeProperty(reference.HostProperty))
{
List <IUnifiedIMObject> objs = Indexes[reference.HostType].GetIndex(reference.HostProperty, reference.GetTargetProperty(obj));
foreach (object o in objs)
{
UpdateReference(reference, (IUnifiedIMObject)o, obj);
}
}
else
if (_databaseGetters.ContainsKey(reference.HostType))
{
foreach (object o in _databaseGetters[reference.HostType])
{
UpdateReference(reference, (IUnifiedIMObject)o, obj);
}
}
}
}
else if (reference.HostType == type)
{
if (UseOmniBase && reference.TargetProperty == "ObjectID")
{
string od = (string)reference.GetHostProperty(obj);
if (od != null)
{
bool hasKey = false;
IUnifiedIMObject omniObj = null;
lock (UnifiedSystem.OmniBase)
{
hasKey = UnifiedSystem.OmniBase.ContainsKey(od);
if (hasKey)
{
omniObj = OmniBase[od];
}
}
if (hasKey)
{
UpdateReference(reference, obj, omniObj);
}
}
}
else
{
if (AllowIndexes && Indexes.ContainsKey(reference.TargetType) && Indexes[reference.TargetType].HasTypeProperty(reference.TargetProperty))
{
List <IUnifiedIMObject> objs = Indexes[reference.TargetType].GetIndex(reference.TargetProperty, reference.GetHostProperty(obj));
foreach (object o in objs)
{
UpdateReference(reference, obj, (IUnifiedIMObject)o);
}
}
else if (_databaseGetters.ContainsKey(reference.TargetType))
{
foreach (object o in _databaseGetters[reference.TargetType])
{
UpdateReference(reference, obj, (IUnifiedIMObject)o);
}
}
}
}
}
internal static void HandleObjectCreation <T>(IUnifiedIMObject obj)
{
if (UnifiedSystem.AllowReferences)
{
UnifiedSystem.ResolveReferences(obj, typeof(T));
}
if (UnifiedSystem.UseOmniBase)
{
lock (UnifiedSystem.OmniBase)
UnifiedSystem.OmniBase.Add(obj.ObjectID, obj);
}
List <string> indexesToAdd = new List <string>();
if (UnifiedSystem.AllowReferences)
{
List <UnifiedIMReference> refs = new List <UnifiedIMReference>();
if (TypeReferences.ContainsKey(typeof(T)))
{
refs = TypeReferences[typeof(T)];
}
/*
* ObjectIndex<IUnifiedIMObject> oi = null;
* if (CreateReferenceIndexes)
* if (Indexes.ContainsKey(typeof(T)))
* oi = Indexes[typeof(T)];*/
foreach (UnifiedIMReference reff in refs)
{
if (reff.HostType == typeof(T))
{
//object value = reff.GetHostProperty(obj);
//if(!obj.PropertyStates.ContainsKey(reff.HostProperty))
//obj.PropertyStates.Add(reff.HostProperty, new UIMPropertyState(value));
if (CreateReferenceIndexes && reff.HostProperty != "ObjectID")
{
// oi.AddIndex(reff.HostProperty, value, obj);
indexesToAdd.Add(reff.HostProperty);
}
}
else if (reff.TargetType == typeof(T))
{
//object value = reff.GetTargetProperty(obj);
//if (!obj.PropertyStates.ContainsKey(reff.TargetProperty))
// obj.PropertyStates.Add(reff.TargetProperty, new UIMPropertyState(value));
if (CreateReferenceIndexes && reff.TargetProperty != "ObjectID")
{
//oi.AddIndex(reff.TargetProperty, value, obj);
indexesToAdd.Add(reff.TargetProperty);
}
}
}
}
if (AllowIndexes)
{
if (IndexProperties.ContainsKey(typeof(T)))
{
indexesToAdd.AddRange(IndexProperties[typeof(T)]);
}
ObjectIndexer <IUnifiedIMObject> oi = null;
if (Indexes.ContainsKey(typeof(T)))
{
oi = Indexes[typeof(T)];
}
if (oi != null)
{
foreach (string idx in indexesToAdd.Distinct())
{
object value = Property.Get(obj, idx);
if (!obj.PropertyStates.ContainsKey(idx))
{
obj.PropertyStates.Add(idx, new UIMPropertyState(value));
}
oi.AddIndex(idx, value, obj);
}
}
}
}
