static void VerifyMetaResourceType(MetaResourceBase metaResource)
{
if (metaResource == null)
{
return;
}
VerifyMetaResourceType(metaResource.GetType(), (error) => { throw new Exception(error); });
}
static void VerifyMetaResourceClone(MetaResourceBase original, MetaResourceBase copy)
{
bool equals = Object.Equals(original, copy);
foreach (var v in original.GetType().GetProperties())
{
if (typeof(MetaResourceBase).IsAssignableFrom(v.PropertyType))
{
var o = (MetaResourceBase)((MetaResourceBase)v.GetValue(original, null));
if (o != null)
{
var c = (MetaResourceBase)o.Clone();
VerifyMetaResourceClone(o, c);
}
}
}
if (!equals)
{
throw new Exception(original + " does not equal " + copy);
}
}
T InnerAcquire <T>(MetaResourceBase metaResource) where T : class
{
if (metaResource == null)
{
return(default(T));
}
var key = new Common.Tuple <MetaResourceBase, Type>(metaResource, typeof(T));
// This is a small optimization, just see if the last acquired object was the same as this one,
// in that case return it. Turns out often around half the acquires can be handled like this
if (Object.Equals(lastAcquiredMetaResource, metaResource))
{
OnAcquire(metaResource);
lastAcquiredResource.References++;
lastAcquiredResource.LastAcquired = pruneK;
return((T)lastAcquiredResource.Object);
}
Resource o = null;
#if THREAD_SAFE_CONTENT
lock (lockObject)
{
#endif
if (contentByMetaResourceAndType.TryGetValue(key, out o))
{
OnAcquire(metaResource);
o.References++;
o.LastAcquired = pruneK;
key.First = (MetaResourceBase)metaResource.Clone();
lastAcquiredMetaResource = key;
lastAcquiredResource = o;
return((T)o.Object);
}
key.First = (MetaResourceBase)metaResource.Clone();
#if DEBUG_CONTENT
if (key.First.GetHashCode() != metaResource.GetHashCode())
{
throw new Exception("Error in meta resource Clone or GetHashCode");
}
if (!Object.Equals(key.First, metaResource))
{
string diffs = "";
key.First.ReportEqualsDiffs(metaResource, (d) => diffs += "\n" + d);
throw new Exception("Error in meta resource Clone or Equals\n\nDiffs:\n" + diffs);
}
#endif
var mapperKey = new Common.Tuple <Type, Type>(metaResource.GetType(), typeof(T));
object ob = mappers[mapperKey].Do(MetaResourceDo.Construct, metaResource, this, null);
OnConstruct(metaResource, ob);
if (ob == null)
{
lastAcquiredMetaResource = new Common.Tuple <MetaResourceBase, Type>(null, null);
lastAcquiredResource = null;
return((T)ob);
}
#if DEBUG_CONTENT
if (key.First.GetHashCode() != metaResource.GetHashCode())
{
throw new Exception("MetaResource was changed during construction (No longer the same hash code)");
}
if (!Object.Equals(key.First, metaResource))
{
throw new Exception("MetaResource was changed during construction (No longer Equals)");
}
#endif
#if THREAD_SAFE_CONTENT
//lock (lockObject)
//{
#endif
OnAcquire(metaResource);
contentByMetaResourceAndType.Add(key, o = new Resource
{
MetaResource = metaResource,
Object = ob,
References = 1,
LastAcquired = pruneK,
FirstAcquired = pruneK
});
#if DEBUG_CONTENT
Resource debugR;
if (contentByResource.TryGetValue(o.Object, out debugR))
{
throw new Exception("Content by resource old: " + debugR.MetaResource + " new: " + o.MetaResource);
}
#endif
contentByResource.Add(o.Object, o);
#if THREAD_SAFE_CONTENT
}
#endif
lastAcquiredMetaResource = key;
lastAcquiredResource = o;
return((T)o.Object);
}