Beispiel #1
0
            protected static bool NeedsFixup(ActiveNodeBase node)
            {
                ActiveDreamNode dreamNode = node as ActiveDreamNode;

                if (dreamNode != null)
                {
                    if (dreamNode.NodeInstance == null)
                    {
                        return(true);
                    }
                }
                else
                {
                    ActiveTimerNode timerNode = node as ActiveTimerNode;
                    if (timerNode != null)
                    {
                        if (timerNode.NodeInstance == null)
                        {
                            return(true);
                        }
                    }
                }

                return(false);
            }
Beispiel #2
0
            protected static void OnLoadFixup(Sim sim, bool initialLoad)
            {
                for (int i = sim.DreamsAndPromisesManager.mActiveNodes.Count - 1; i >= 0; i--)
                {
                    ActiveNodeBase node = sim.DreamsAndPromisesManager.mActiveNodes[i];
                    if ((initialLoad) || (NeedsFixup(node)))
                    {
                        try
                        {
                            node.OnLoadFixup();
                        }
                        catch (Exception e)
                        {
                            Common.Exception(sim.SimDescription, e);
                        }

                        if (NeedsFixup(node))
                        {
                            sim.DreamsAndPromisesManager.mActiveNodes.RemoveAt(i);
                        }
                        else
                        {
                            try
                            {
                                sim.DreamsAndPromisesManager.AddToReferenceList(node);
                            }
                            catch (Exception e)
                            {
                                Common.Exception(sim.SimDescription, e);
                            }
                        }
                    }
                }

                for (int i = sim.DreamsAndPromisesManager.mSleepingNodes.Count - 1; i >= 0; i--)
                {
                    ActiveNodeBase node = sim.DreamsAndPromisesManager.mSleepingNodes[i];
                    if (NeedsFixup(node))
                    {
                        try
                        {
                            node.OnLoadFixup();
                        }
                        catch (Exception e)
                        {
                            Common.Exception(sim.SimDescription, e);
                        }

                        if (NeedsFixup(node))
                        {
                            sim.DreamsAndPromisesManager.mSleepingNodes.RemoveAt(i);
                        }
                    }
                }
            }
        protected override DereferenceResult Perform(DreamsAndPromisesManager reference, FieldInfo field, List <ReferenceWrapper> objects)
        {
            if (Matches(reference, "mPotentialRemovalNodes", field, objects))
            {
                if (Performing)
                {
                    foreach (ReferenceWrapper obj in objects)
                    {
                        List <ActiveDreamNode> nodes;
                        if (reference.mPotentialRemovalNodes.TryGetValue(obj, out nodes))
                        {
                            foreach (ActiveDreamNode node in nodes)
                            {
                                reference.RemoveActiveNode(node, false);
                                reference.mSleepingNodes.Remove(node);

                                reference.RemoveDisplayedPromiseNode(node);
                            }
                        }

                        reference.mPotentialRemovalNodes.Remove(obj);
                    }
                }

                return(DereferenceResult.End);
            }

            if (Matches(reference, "mActor", field, objects))
            {
                Remove(ref reference.mActor);
                return(DereferenceResult.End);
            }

            if (Matches(reference, "mActiveNodes", field, objects))
            {
                if (Performing)
                {
                    ActiveNodeBase node = Find <ActiveNodeBase>(objects);
                    if (node != null)
                    {
                        try
                        {
                            reference.RemoveActiveNode(node);
                        }
                        catch
                        { }
                    }
                }

                return(DereferenceResult.End);
            }

            return(DereferenceResult.Failure);
        }
Beispiel #4
0
        protected static void OnLoadFixup(Sim sim, bool initialLoad)
        {
            for (int i = sim.DreamsAndPromisesManager.mActiveNodes.Count - 1; i >= 0; i--)
            {
                ActiveNodeBase node = sim.DreamsAndPromisesManager.mActiveNodes[i];
                if ((initialLoad) ||
                    (NeedsFixup(node)))
                {
                    try{
                        node.OnLoadFixup();
                    }catch (Exception exception) {
                        //  Get stack trace for the exception. with source file information
                        var st = new StackTrace(exception, true);
                        //  Get the top stack frame
                        var frame = st.GetFrame(0);
                        //  Get the line number from the stack frame
                        var line = frame.GetFileLineNumber();
                        Alive.WriteLog(exception.Message + "\n\n" +
                                       exception.StackTrace + "\n\n" +
                                       exception.Source + "\n\n" +
                                       line);
                    }finally{
                    }

                    if (NeedsFixup(node))
                    {
                        sim.DreamsAndPromisesManager.mActiveNodes.RemoveAt(i);
                    }
                    else
                    {
                        try{
                            sim.DreamsAndPromisesManager.AddToReferenceList(node);
                        }catch (Exception exception) {
                            //  Get stack trace for the exception. with source file information
                            var st = new StackTrace(exception, true);
                            //  Get the top stack frame
                            var frame = st.GetFrame(0);
                            //  Get the line number from the stack frame
                            var line = frame.GetFileLineNumber();
                            Alive.WriteLog(exception.Message + "\n\n" +
                                           exception.StackTrace + "\n\n" +
                                           exception.Source + "\n\n" +
                                           line);
                        }finally{
                        }
                    }
                }
            }
            for (int i = sim.DreamsAndPromisesManager.mSleepingNodes.Count - 1; i >= 0; i--)
            {
                ActiveNodeBase node = sim.DreamsAndPromisesManager.mSleepingNodes[i];
                if (NeedsFixup(node))
                {
                    try{
                        node.OnLoadFixup();
                    }catch (Exception exception) {
                        //  Get stack trace for the exception. with source file information
                        var st = new StackTrace(exception, true);
                        //  Get the top stack frame
                        var frame = st.GetFrame(0);
                        //  Get the line number from the stack frame
                        var line = frame.GetFileLineNumber();
                        Alive.WriteLog(exception.Message + "\n\n" +
                                       exception.StackTrace + "\n\n" +
                                       exception.Source + "\n\n" +
                                       line);
                    }finally{
                    }
                    if (NeedsFixup(node))
                    {
                        sim.DreamsAndPromisesManager.mSleepingNodes.RemoveAt(i);
                    }
                }
            }
        }