public static void OnLoadArrayReference(object list, ref object parent)
{
if (!ErrorTrapTuning.kPerformDereferencing)
{
return;
}
using (TestSpan span = new TestSpan(TimeSpanLogger.Bin, "OnLoadArrayReferences", DebuggingLevel))
{
try
{
if ((parent == null) || (list == null))
{
return;
}
if (IsIgnored(list))
{
return;
}
ObjectLookup.Add(list, parent, null);
}
catch (Exception e)
{
DebugException("Parent: " + parent.GetType().ToString() + Common.NewLine + "List: " + list.GetType().ToString(), e);
}
}
}
public LuceneQueryExecutor(Context context, ObjectLookup <TDocument> newItem, IDocumentMapper <TDocument> mapper)
: base(context)
{
this.newItem = newItem;
this.mapper = mapper;
this.keyConverter = mapper as IDocumentKeyConverter;
}
protected override void PreProcess(Delegate obj, object parent, FieldInfo field)
{
if (obj.Target != null)
{
ObjectLookup.Add(obj.Target, obj, null);
}
}
public void OnWorldLoadFinished()
{
sLoading = false;
sChecked.Clear();
ObjectLookup.StartListener();
foreach (ObjectGuid guid in new List <ObjectGuid>(sAllRunning.Keys))
{
IScriptProxy proxy = Simulator.GetProxy(guid);
if (proxy != null && proxy.Target != null)
{
OneShotFunction oneShot = proxy.Target as OneShotFunction;
if (oneShot != null && oneShot.mFunction != null)
{
IGameObject obj = oneShot.mFunction.Target as IGameObject;
if (obj != null && obj.HasBeenDestroyed)
{
Simulator.DestroyObject(guid);
LogCorrection("Removed Orphan OneShotFunction");
LogCorrection(" " + oneShot.mFunction.Method.DeclaringType.ToString());
LogCorrection(" " + oneShot.mFunction.Target.GetType());
continue;
}
}
}
}
new Common.AlarmTask(1, TimeUnit.Minutes, OnDelayedWorldLoadFinished);
}
protected override void Perform(SimDescription obj, object parent, FieldInfo field)
{
//if (obj.IsValidDescription) return;
if (mSims == null)
{
mSims = SimListing.AllSims <SimDescription>(null, true);
}
// All residents, ancestors, and urnstone sims are considered valid
if (mSims.ContainsKey(obj.SimDescriptionId))
{
return;
}
GameObjectReference reference = ObjectLookup.GetReference(new ReferenceWrapper(obj));
if (!DereferenceManager.Perform(obj, reference, false, false))
{
return;
}
DereferenceManager.Perform(obj, reference, true, false);
string fullName = obj.FullName;
if (!string.IsNullOrEmpty(fullName))
{
fullName = fullName.Trim();
}
if (!string.IsNullOrEmpty(fullName))
{
bool found = false;
foreach (List <SimDescription> list in mSims.Values)
{
foreach (SimDescription sim in list)
{
if (sim.FullName == fullName)
{
found = true;
break;
}
}
}
if (!found)
{
if (reference.Count > 0)
{
ErrorTrap.LogCorrection("SimDescription Removed: " + fullName);
}
else
{
ErrorTrap.DebugLogCorrection("Zero Reference SimDescription Removed: " + fullName);
}
}
}
}
public bool HasObject <T>(uint objectId)
{
if (ObjectLookup.ContainsKey(typeof(T)))
{
return(ObjectLookup[typeof(T)].ContainsKey(objectId));
}
return(false);
}
/// <summary>
/// Opens a session for staging changes and then committing them atomically.
/// </summary>
/// <param name="lookup">Factory delegate that resolves instances of <typeparamref name="T"/></param>
/// <param name="documentMapper">Mapper that will convert documents to objects and vice versa.</param>
/// <param name="documentModificationDetector">Helper to determine when instances of <typeparamref name="T"/> are modified
/// and need to be updated in the index when the session is committed.
/// </param>
/// <typeparam name="T">The type of object that will be mapped to <c cref="Document"/>.</typeparam>
public virtual ISession <T> OpenSession <T>(ObjectLookup <T> lookup, IDocumentMapper <T> documentMapper, IDocumentModificationDetector <T> documentModificationDetector)
{
perFieldAnalyzer.Merge(documentMapper.Analyzer);
return(new LuceneSession <T>(
documentMapper,
documentModificationDetector,
IndexWriter,
context,
CreateQueryable(lookup, context, documentMapper)));
}
public T GetObject <T>(uint objectId) where T : ToffeeObject
{
if (ObjectLookup.ContainsKey(typeof(T)))
{
if (ObjectLookup[typeof(T)].ContainsKey(objectId))
{
return((T)ObjectLookup[typeof(T)][objectId]);
}
}
return(null);
}
/// <summary>
/// Empty the NetGuidCache
/// </summary>
public void Cleanup()
{
NetFieldExportGroupIndexToGroup.Clear();
NetFieldExportGroupMap.Clear();
NetGuidToPathName.Clear();
ObjectLookup.Clear();
NetFieldExportGroupMapPathFixed.Clear();
_archTypeToExportGroup.Clear();
_cleanedPaths.Clear();
_cleanedClassNetCache.Clear();
}
protected List <KeyValuePair <object, FieldInfo> > GetReferences(object obj)
{
GameObjectReference reference = ObjectLookup.GetReference(new ReferenceWrapper(obj));
if (reference == null)
{
return(new List <KeyValuePair <object, FieldInfo> >());
}
else
{
return(reference.GetFullReferenceList());
}
}
public void OnWorldQuit()
{
sLoading = true;
//sDelayLoading = true;
DereferenceManager.Logger.OnWorldQuit = true;
ObjectLookup.Clear();
sObjectsOfInterest.Clear();
sAllRunning.Clear();
}
/// <summary>
/// Opens a session for staging changes and then committing them atomically.
/// </summary>
/// <param name="lookup">Factory delegate that creates new instances of <typeparamref name="T"/></param>
/// <param name="documentMapper">Mapper that will convert documents to objects and vice versa.</param>
/// <typeparam name="T">The type of object that will be mapped to <c cref="Document"/>.</typeparam>
public ISession <T> OpenSession <T>(ObjectLookup <T> lookup, IDocumentMapper <T> documentMapper)
{
var documentModificationDetector = documentMapper as IDocumentModificationDetector <T>;
if (documentModificationDetector == null)
{
throw new ArgumentException(
string.Format("The type {0} must implement {1} or else a separate implementation of {1} must be provided using an alternate overload.",
documentMapper.GetType(),
typeof(IDocumentModificationDetector <T>)),
"documentMapper");
}
return(OpenSession(lookup, documentMapper, documentModificationDetector));
}
protected virtual void SubPerform(T obj, object parent, FieldInfo field, Dictionary <ReferenceWrapper, bool> performed, OnProcess process)
{
ReferenceWrapper child = new ReferenceWrapper(obj);
if (ObjectLookup.WasPostDisposed(child))
{
return;
}
if (performed.ContainsKey(child))
{
return;
}
performed.Add(child, true);
process(obj, parent, field);
}
public static void OnLoadReference(ref object child, ref object parent, FieldInfo field)
{
if (!ErrorTrapTuning.kPerformDereferencing)
{
return;
}
using (TestSpan span = new TestSpan(TimeSpanLogger.Bin, "OnLoadReference", DebuggingLevel))
{
try
{
if ((parent == null) || (child == null))
{
return;
}
if (IsIgnored(child))
{
return;
}
try
{
child.GetHashCode();
parent.GetHashCode();
}
catch
{
return;
}
sReferencesCounted++;
ObjectLookup.Add(child, parent, field);
}
catch (Exception e)
{
DebugException("Parent: " + parent.GetType().ToString() + Common.NewLine + "Child: " + child.GetType().ToString(), e);
}
}
}
public void ConvertDocument()
{
var capturedKey = (IDocumentKey)null;
var record = new Record();
ObjectLookup <Record> lookup = k => { capturedKey = k; return(record); };
var enhancedMapper = MockRepository.GenerateStrictMock <IDocumentMapperWithConverter>();
executor = new TestableLuceneQueryExecutor <Record>(new Context(new RAMDirectory(), new object()), lookup, enhancedMapper);
var key = new DocumentKey();
enhancedMapper.Expect(m => m.ToKey(document)).Return(key);
enhancedMapper.Expect(m => m.ToObject(document, context, record));
var result = executor.ConvertDocument(document, context);
Assert.That(capturedKey, Is.SameAs(key), "Captured Key");
Assert.That(result, Is.SameAs(record), "Record");
enhancedMapper.VerifyAllExpectations();
}
private void AddObject(ToffeeObject tObject)
{
if (tObject.Network != this)
{
throw new ToffeeException("Tried to add object to network '{0}' but object belongs to '{1}'", Name, tObject.Network.Name);
}
if (Objects.ContainsKey(tObject.GetType()))
{
Objects[tObject.GetType()].Add(tObject);
ObjectIdentifierLookup[tObject.GetType()].Add(tObject.FullName, tObject);
ObjectLookup[tObject.GetType()].Add(tObject.ObjectId, tObject);
}
else
{
Objects.Add(tObject.GetType(), new List <ToffeeObject>());
ObjectIdentifierLookup.Add(tObject.GetType(), new Dictionary <string, ToffeeObject>());
ObjectLookup.Add(tObject.GetType(), new Dictionary <uint, ToffeeObject>());
Objects[tObject.GetType()].Add(tObject);
ObjectIdentifierLookup[tObject.GetType()].Add(tObject.FullName, tObject);
ObjectLookup[tObject.GetType()].Add(tObject.ObjectId, tObject);
}
}
protected override void Perform(EventListener obj, object parent, FieldInfo field)
{
if (!DereferenceManager.HasBeenDestroyed(obj.TargetObject))
{
return;
}
if (DereferenceManager.Perform(obj, ObjectLookup.GetReference(new ReferenceWrapper(obj)), false, false))
{
EventTracker.RemoveListener(obj);
obj.CompletionDelegate = null;
obj.mScriptObject = null;
obj.mTargetObject = null;
DelegateListener delListener = obj as DelegateListener;
if (delListener != null)
{
delListener.mProcessEvent = null;
}
DereferenceManager.Perform(obj, ObjectLookup.GetReference(new ReferenceWrapper(obj)), true, false);
}
}
protected override void Perform(object obj, object parent, FieldInfo field)
{
DereferenceManager.Perform(obj, ObjectLookup.GetReference(new ReferenceWrapper(obj)), false, true);
}
protected override void Perform(GameObject obj, object referenceParent, FieldInfo field)
{
if (obj is Ocean)
{
if (LotManager.sOceanObject == obj)
{
return;
}
}
else if (obj is Terrain)
{
if (Terrain.sTerrain == obj)
{
return;
}
}
if (DereferenceManager.HasBeenDestroyed(obj))
{
if (obj is Sim)
{
LotManager.sActorList.Remove(obj as Sim);
DereferenceManager.Perform(obj, ObjectLookup.GetReference(new ReferenceWrapper(obj)), true, false);
}
else
{
GameObjectReference refObj = ObjectLookup.GetReference(new ReferenceWrapper(obj));
if (DereferenceManager.Perform(obj, refObj, false, false))
{
DereferenceManager.Perform(obj, refObj, true, false);
ErrorTrap.LogCorrection("Destroyed Object Found: " + obj.GetType());
}
}
return;
}
if (kShowFullReferencing)
{
DereferenceManager.Perform(obj, ObjectLookup.GetReference(new ReferenceWrapper(obj)), false, true);
}
if (obj.InWorld)
{
return;
}
if (obj.InInventory)
{
if (Inventories.ParentInventory(obj) == null)
{
if ((obj.Parent != null) || (Consignment.ContainsKey(obj)))
{
obj.SetFlags(GameObject.FlagField.InInventory, false);
ErrorTrap.LogCorrection("Invalid Inventory Object Unflagged: " + obj.GetType());
}
else
{
ErrorTrap.LogCorrection("Invalid Inventory Object Found: " + obj.GetType());
ErrorTrap.AddToBeDeleted(obj, true);
}
}
return;
}
else
{
if (SharedInventories.ContainsKey(obj.ObjectId))
{
obj.SetFlags(GameObject.FlagField.InInventory, true);
ErrorTrap.LogCorrection("Inventory Object Flagged: " + obj.GetType());
return;
}
}
if (EventItems.ContainsKey(obj.ObjectId))
{
return;
}
bool hasParent = false;
IGameObject parent = obj.Parent;
while (parent != null)
{
hasParent = true;
if (DereferenceManager.HasBeenDestroyed(parent))
{
ErrorTrap.LogCorrection("Destroyed Parent Object Found: " + parent.GetType());
ErrorTrap.AddToBeDeleted(obj, true);
hasParent = false;
break;
}
parent = parent.Parent;
}
if (!hasParent)
{
ReferenceWrapper refObj = new ReferenceWrapper(obj);
GameObjectReference reference = ObjectLookup.GetReference(refObj);
if ((reference != null) && (reference.HasReferences))
{
if (DereferenceManager.Perform(obj, ObjectLookup.GetReference(refObj), false, false))
{
IScriptProxy proxy = Simulator.GetProxy(obj.ObjectId);
if (proxy != null)
{
IScriptLogic logic = proxy.Target;
if (object.ReferenceEquals(logic, obj))
{
bool log = !sSilentDestroy.ContainsKey(obj.GetType());
if (log)
{
ErrorTrap.LogCorrection("Out of World Object Found 2: " + obj.GetType());
}
else
{
ErrorTrap.DebugLogCorrection("Out of World Object Found 3: " + obj.GetType());
}
ErrorTrap.AddToBeDeleted(obj, log);
}
else
{
ErrorTrap.DebugLogCorrection("Out of World Object Found 4: " + obj.GetType());
ErrorTrap.DebugLogCorrection("Out of World Object Found 5: " + logic.GetType());
}
}
else
{
DereferenceManager.Perform(obj, ObjectLookup.GetReference(refObj), true, false);
}
}
}
else
{
ErrorTrap.LogCorrection("Out of World Object Found 1: " + obj.GetType());
ErrorTrap.AddToBeDeleted(obj, true);
}
}
}
public TestableLuceneQueryExecutor(Context context, ObjectLookup <T> newItem, IDocumentMapper <T> mapper) : base(context, newItem, mapper)
{
}
private LuceneQueryable <T> CreateQueryable <T>(ObjectLookup <T> factory, Context context, IDocumentMapper <T> mapper)
{
var executor = new LuceneQueryExecutor <T>(context, factory, mapper);
return(new LuceneQueryable <T>(queryParser, executor));
}
/// <summary>
/// Registers a callback to be invoked when a new IndexSearcher is being initialized.
/// This method allows an IndexSearcher to be "warmed up" by executing one or more
/// queries before the instance becomes visible on other threads.
///
/// While callbacks are being executed, other threads will continue to use the previous
/// instance of IndexSearcher if this is not the first instance being initialized.
///
/// If this is the first instance, other threads will block until all callbacks complete.
/// </summary>
public void RegisterCacheWarmingCallback <T>(Action <IQueryable <T> > callback, ObjectLookup <T> lookup, IDocumentMapper <T> documentMapper)
{
context.SearcherLoading += (s, e) =>
{
Log.Trace(m => m("Invoking cache warming callback " + lookup));
var warmupContext = new WarmUpContext(context, e.IndexSearcher);
var queryable = CreateQueryable(lookup, warmupContext, documentMapper);
callback(queryable);
Log.Trace(m => m("Callback {0} completed.", lookup));
};
}
/// <summary>
/// <see cref="RegisterCacheWarmingCallback{T}(System.Action{System.Linq.IQueryable{T}}, ObjectLookup{T}, IDocumentMapper{T})"/>
/// </summary>
public void RegisterCacheWarmingCallback <T>(Action <IQueryable <T> > callback, ObjectLookup <T> lookup)
{
RegisterCacheWarmingCallback(callback, lookup, new ReflectionDocumentMapper <T>(version, null));
}
public override ISession <T> OpenSession <T>(ObjectLookup <T> factory, IDocumentMapper <T> documentMapper, IDocumentModificationDetector <T> documentModificationDetector)
{
throw new InvalidOperationException("Cannot open sessions in read-only mode.");
}
public void OnDelayedWorldLoadFinished()
{
sObjectsOfInterest.Clear();
List <ICheck> checks = DerivativeSearch.Find <ICheck>();
foreach (ICheck check in checks)
{
check.Finish();
}
EventTracker.sCurrentlyUpdatingDreamsAndPromisesManagers = false;
new CheckRoleManager().Perform(RoleManager.sRoleManager, true);
CheckRecovery();
CheckOutfits();
CheckLotObjects();
Inventories.CheckInventories(LogCorrection, DebugLogCorrection, true);
List <IDereferenceController> controllers = DerivativeSearch.Find <IDereferenceController>();
foreach (IDereferenceController controller in controllers)
{
controller.Clear();
foreach (KeyValuePair <Type, List <ObjectLookup.Item> > list in ObjectLookup.List)
{
controller.Add(list.Key, list.Value);
}
controller.PreProcess();
}
if (ErrorTrapTuning3.kLogCounting)
{
using (TestSpan span = new TestSpan(ExternalTimeSpanLogger.sLogger, "Log Counts"))
{
ObjectLookup.LogCounts();
}
}
DereferenceManager.Logger.OnWorldQuit = false;
try
{
DereferenceManager.Logger.sCollecting = true;
using (Common.TestSpan totalSpan = new Common.TestSpan(TimeSpanLogger.Bin, "Dereferencing", DebugLevel.Stats))
{
foreach (IDereferenceController controller in controllers)
{
controller.Perform();
if (DereferenceManager.Logger.OnWorldQuit)
{
break;
}
}
}
}
finally
{
DereferenceManager.Logger.sCollecting = false;
}
using (Common.TestSpan totalSpan = new Common.TestSpan(TimeSpanLogger.Bin, "Dereferencing", DebugLevel.Stats))
{
foreach (IDereferenceController controller in controllers)
{
controller.PostPerform();
if (DereferenceManager.Logger.OnWorldQuit)
{
break;
}
}
}
// Possibly loaded by Dereference
sResidents = null;
ProcessToBeDeleted(sToBeDeleted, true);
ProcessToBeDeleted(sSilentToBeDeleted, false);
ObjectLookup.Clear();
//sDelayLoading = false;
RecordErrors();
}
/// <summary>
/// <see cref="OpenSession{T}(ObjectLookup{T}, IDocumentMapper{T}, IDocumentModificationDetector{T})"/>
/// </summary>
public ISession <T> OpenSession <T>(ObjectLookup <T> lookup)
{
var reflectionDocumentMapper = new ReflectionDocumentMapper <T>(version, externalAnalyzer);
return(OpenSession(lookup, reflectionDocumentMapper, reflectionDocumentMapper));
}
/// <summary>
/// Returns an IQueryable implementation where the type being mapped
/// from <c cref="Document"/> is constructed by a factory delegate.
/// </summary>
/// <typeparam name="T">The type of object that Document will be mapped onto.</typeparam>
/// <param name="lookup">Factory method to instantiate new instances of T.</param>
/// <param name="documentMapper">Mapper that will convert documents to objects and vice versa.</param>
public IQueryable <T> AsQueryable <T>(ObjectLookup <T> lookup, IDocumentMapper <T> documentMapper)
{
return(CreateQueryable(lookup, context, documentMapper));
}
/// <summary>
/// <see cref="AsQueryable{T}(ObjectLookup{T}, IDocumentMapper{T})"/>
/// </summary>
public IQueryable <T> AsQueryable <T>(ObjectLookup <T> lookup)
{
return(AsQueryable(lookup, new ReflectionDocumentMapper <T>(version, externalAnalyzer)));
}
public static bool Perform(object obj, GameObjectReference references, bool perform, bool reportFound)
{
bool immediate = false;
bool report = true;
if ((obj is RabbitHoleDoorJig) || (obj is PhoneCell))
{
report = ErrorTrap.kDebugging;
}
else if (obj is Lot)
{
immediate = true;
}
else if (obj is Sim)
{
Sim sim = obj as Sim;
if (sim.LotHome != null)
{
if ((RecoverMissingSimTask.FindPlaceholderForSim(sim.SimDescription) == null) &&
((sim.SimDescription.CreatedSim == null) || (sim.SimDescription.CreatedSim == sim)))
{
immediate = true;
}
}
}
ReferenceLog log = null;
if (!perform)
{
log = new ReferenceLog("Potential Object Found: " + ErrorTrap.GetQualifiedName(obj), report, immediate);
}
if (references == null)
{
return(false);
}
if ((!ErrorTrap.kDebugging) && (references.Count == 0))
{
return(false);
}
if (perform)
{
log = new ReferenceLog("Destroyed Object Found: " + ErrorTrap.GetQualifiedName(obj), report, immediate);
}
log.Perform = perform;
log.ReportFound = reportFound;
if ((!ErrorTrap.kDebugging) && (obj is Lot))
{
return(false);
}
List <DereferenceStack> stack = new List <DereferenceStack>();
foreach (KeyValuePair <object, FieldInfo> pair in references)
{
stack.Add(new DereferenceStack(pair, new Dictionary <ReferenceWrapper, bool>(), new List <ReferenceWrapper>(), new ReferenceWrapper(obj), false, false));
}
bool firstFailure = true;
int index = 0;
while (index < stack.Count)
{
DereferenceStack stackObject = stack[index];
index++;
ReferenceWrapper key = new ReferenceWrapper(stackObject.mReference.Key);
bool recursion = false;
if (stackObject.ContainsKey(key))
{
recursion = true;
}
if ((perform) && (stackObject.Count == 1))
{
log.DumpLog(false);
}
object reference = stackObject.mReference.Key;
string depth = "";
for (int i = 0; i < stackObject.Count - 1; i++)
{
depth += " ";
}
bool reset = false, success = false;
foreach (IDereference dereference in DereferenceManager.Dereferences)
{
DereferenceResult result = dereference.IPerform(stackObject.mReference, stackObject.mList, perform);
if (result == DereferenceResult.Found)
{
log.SetFoundSuccess();
}
if (result != DereferenceResult.Failure)
{
stackObject.mResult = depth + " Reference " + result + ": " + reference.GetType() + " " + stackObject.mReference.Value + " (Using " + dereference.GetType().Name + ")";
if (report)
{
log.Add(stackObject.mResult);
}
success = true;
bool checkSuccess = false;
if (reference is GameObject)
{
stackObject.mEndFound = true;
checkSuccess = true;
GameObject gameObject = reference as GameObject;
if ((perform) && (!HasBeenDestroyed(gameObject)) && (!reset) && (!(reference is Sim)))
{
try
{
reset = true;
gameObject.SetObjectToReset();
log.Add(depth + " Object Reset: " + ErrorTrap.GetQualifiedName(gameObject));
}
catch //(Exception e)
{
//Common.DebugException(gameObject, e);
}
}
}
else
{
switch (result)
{
case DereferenceResult.End:
case DereferenceResult.Found:
stackObject.mEndFound = true;
break;
case DereferenceResult.Continue:
case DereferenceResult.ContinueIfReferenced:
case DereferenceResult.Ignore:
bool unimportant = stackObject.mUnimportant;
switch (result)
{
case DereferenceResult.ContinueIfReferenced:
unimportant = true;
break;
case DereferenceResult.Ignore:
unimportant = true;
stackObject.mEndFound = true;
break;
}
if (!recursion)
{
if (ShouldRecurse(reference))
{
bool referenced = false;
GameObjectReference gameReference = ObjectLookup.GetReference(key);
if (gameReference != null)
{
foreach (KeyValuePair <object, FieldInfo> pair in gameReference)
{
stack.Insert(index, new DereferenceStack(pair, stackObject, key, unimportant, stackObject.mEndFound));
referenced = true;
}
}
if (!referenced)
{
checkSuccess = true;
if (result == DereferenceResult.ContinueIfReferenced)
{
stackObject.mEndFound = true;
}
}
else
{
stackObject.mBridge = true;
}
}
else
{
stackObject.mEndFound = true;
}
}
else if (result == DereferenceResult.ContinueIfReferenced)
{
stackObject.mEndFound = true;
}
else
{
checkSuccess = true;
}
break;
default:
if (recursion)
{
checkSuccess = true;
}
break;
}
}
if (checkSuccess)
{
switch (result)
{
case DereferenceResult.End:
case DereferenceResult.Ignore:
break;
default:
if (recursion)
{
if (!object.ReferenceEquals(key.mObject, obj))
{
log.SetFailure("A");
}
else
{
stackObject.mEndFound = true;
}
}
else
{
log.SetFailure("B");
}
break;
}
}
}
}
if (!success)
{
bool mustRecurse = false;
string priority = "UNHANDLED";
if (recursion)
{
priority = "Recursion";
if (object.ReferenceEquals(key.mObject, obj))
{
stackObject.mEndFound = true;
}
else
{
stackObject.mBridge = true;
}
}
else if ((reference.GetType().IsArray) ||
(reference is IList) ||
(reference is IDictionary) ||
(reference is ICollection) ||
(reference.GetType().Name.Contains("ForgetfulList")) ||
(reference.GetType().Name.Contains("PairedListDictionary")))
{
priority = "Bridge";
mustRecurse = true;
stackObject.mBridge = true;
}
else if (stackObject.mUnimportant)
{
priority = "Ancillary";
if ((reference is GameObject) || (reference is SimDescription))
{
recursion = true;
}
else
{
mustRecurse = true;
}
stackObject.mBridge = true;
}
else
{
log.ImportantFound();
log.SetFailure("C");
}
stackObject.mResult = depth + " " + priority + " Reference: " + ErrorTrap.GetQualifiedName(reference) + " " + stackObject.mReference.Value;
if (report)
{
log.Add(stackObject.mResult);
}
bool referenced = false;
if (!recursion)
{
if (ShouldRecurse(reference))
{
GameObjectReference gameReference = ObjectLookup.GetReference(key);
if (gameReference != null)
{
foreach (KeyValuePair <object, FieldInfo> pair in gameReference)
{
stack.Insert(index, new DereferenceStack(pair, stackObject, key, stackObject.mUnimportant, stackObject.mEndFound));
referenced = true;
}
}
}
else
{
stackObject.mEndFound = true;
mustRecurse = false;
}
}
if (!referenced)
{
if (mustRecurse)
{
log.SetFailure("D");
}
}
else
{
stackObject.mBridge = true;
}
}
if ((!perform) && (!log.IsTotalSuccess) && (firstFailure))
{
firstFailure = false;
log.Add(depth + " RETAINED " + log.FailureReason);
}
}
bool first = true;
foreach (DereferenceStack stackObject in stack)
{
if (stackObject.mEndFound)
{
continue;
}
if (stackObject.mBridge)
{
continue;
}
log.EndMissing();
if (first)
{
first = false;
log.Add(" OPEN ENDED");
}
log.Add(stackObject.mResult);
}
log.DumpLog(false);
Logger.ForceRecord();
return(log.IsTotalSuccess);
}
