private void ConnectRootNode(TraceStepExpr tsExpr, BehaviorGraphNode parentNode) { Debug.Assert(parentNode != null); var newNodeProp1 = new InnerLoopBehaviorState(tsExpr.TraceStep.Source); var newNode1 = new BehaviorGraphNode(newNodeProp1); var newNodeProp2 = new InnerLoopBehaviorState(tsExpr.TraceStep.Target); var newNode2 = new BehaviorGraphNode(newNodeProp2); InnerLoopEdgeProperty newEdgeProp; if (tsExpr.TraceStep.WrongStep) { newEdgeProp = new InnerLoopEdgeProperty(); } else { newEdgeProp = new InnerLoopEdgeProperty((string)tsExpr.TraceStep.Rule, (string)tsExpr.TraceStep.AppliedRule); } var newEdge = new BehaviorGraphEdge(newNode1, newNode2, newEdgeProp); newNode1.OutEdges.Add(newEdge); newNode2.InEdges.Add(newEdge); parentNode.SubGraph.Nodes.Add(newNode1); parentNode.SubGraph.Nodes.Add(newNode2); }
public void Insert(IEnumerable <Tuple <object, object> > kt) { //start node var startState = new BehaviorGraphNode(new OuterLoopBehaviorState()); _nodes.Add(startState); Debug.Assert(kt != null); BehaviorGraphNode source = startState; foreach (var tuple in kt) { var strategy = tuple.Item1 as string; var tsExpr = tuple.Item2 as List <TraceStepExpr>; Debug.Assert(strategy != null); Debug.Assert(tsExpr != null); var traceSteps = tsExpr.Select(tse => tse.TraceStep).ToList(); var outerEdgeProp = new OuterLoopEdgeProperty(strategy); var nodeState = new OuterLoopBehaviorState(traceSteps); var target = new BehaviorGraphNode(nodeState); _nodes.Add(target); var newEdge = new BehaviorGraphEdge(source, target, outerEdgeProp); source.OutEdges.Add(newEdge); target.InEdges.Add(newEdge); source = target; } }
public BehaviorGraphNode SearchOuterLoopNode(BehaviorGraphNode inputInnerNode) { var innerState = inputInnerNode.State as InnerLoopBehaviorState; Debug.Assert(innerState != null); Debug.Assert(inputInnerNode.SubGraph == null); foreach (BehaviorGraphNode outerNode in Nodes) { if (outerNode.SubGraph == null) { continue; } var internalNodes = outerNode.SubGraph.Nodes; foreach (BehaviorGraphNode innerNode in internalNodes) { bool result = innerNode.Equals(inputInnerNode); if (result) { return(outerNode); } } } return(null); }
private void ConnectNextNode(TraceStepExpr tsExpr, BehaviorGraphNode gn2) { var newNodeProp = new InnerLoopBehaviorState(tsExpr.TraceStep.Source); var newNode = new BehaviorGraphNode(newNodeProp); InnerLoopEdgeProperty newEdgeProp; if (tsExpr.TraceStep.WrongStep) { newEdgeProp = new InnerLoopEdgeProperty(); } else { newEdgeProp = new InnerLoopEdgeProperty((string)tsExpr.TraceStep.Rule, (string)tsExpr.TraceStep.AppliedRule); } var newEdge = new BehaviorGraphEdge(newNode, gn2, newEdgeProp); /*foreach (var edge in gn2.InEdges) * { * var prevNode = edge.Source; * prevNode.OutEdges.Add(newEdge); * }*/ gn2.InEdges.Add(newEdge); newNode.OutEdges.Add(newEdge); BehaviorGraphNode parentNode = SearchOuterLoopNode(gn2); parentNode.SubGraph.Nodes.Add(newNode); }
private void InitSubGraph() { var outerState = _state as OuterLoopBehaviorState; if (outerState == null) return; var steps = outerState.Traces; if (steps == null || steps.Count == 0) return; _subGraph = new BehaviorGraph(); var ts1 = steps[0]; var startState = new BehaviorGraphNode(new InnerLoopBehaviorState(ts1.Source)); _subGraph.Nodes.Add(startState); BehaviorGraphNode source = startState; for(int i = 0; i < outerState.Traces.Count; i++) { var ts = outerState.Traces[i]; var nodeState = new InnerLoopBehaviorState(ts.Target); var target = new BehaviorGraphNode(nodeState); _subGraph.Nodes.Add(target); var innerEdgeProp = new InnerLoopEdgeProperty((string)ts.Rule, (string)ts.AppliedRule); var newEdge = new BehaviorGraphEdge(source, target, innerEdgeProp); source.OutEdges.Add(newEdge); target.InEdges.Add(newEdge); source = target; } }
//TODO public int CurrentSubGraphPathFinding(BehaviorGraphNode outerLoopNode) { var obj = SearchInnerLoopNode(outerLoopNode); var innerNode = obj as BehaviorGraphNode; var innerNodeLst = obj as List<BehaviorGraphNode>; BehaviorGraphNode sourceNode = null; if (innerNode != null) sourceNode = innerNode; if (innerNodeLst != null) sourceNode = innerNodeLst[0]; int parentIndex = SearchOuterLoopNodeIndex(sourceNode); int count = 0; while (sourceNode != null && sourceNode.OutEdges.Count != 0) { var nextObj = SearchNextInnerLoopNode(sourceNode); var nextNode = obj as BehaviorGraphNode; var nextNodeLst = obj as List<BehaviorGraphNode>; if (nextNodeLst != null) nextNode = nextNodeLst[0]; int outerLoopIndex = SearchOuterLoopNodeIndex(nextNode); if (outerLoopIndex != parentIndex) break; count++; } return count; }
public void Insert(IEnumerable<Tuple<object, object>> kt) { //start node var startState = new BehaviorGraphNode(new OuterLoopBehaviorState()); _nodes.Add(startState); Debug.Assert(kt != null); BehaviorGraphNode source = startState; foreach (var tuple in kt) { var strategy = tuple.Item1 as string; var tsExpr = tuple.Item2 as List<TraceStepExpr>; Debug.Assert(strategy != null); Debug.Assert(tsExpr != null); var traceSteps = tsExpr.Select(tse => tse.TraceStep).ToList(); var outerEdgeProp = new OuterLoopEdgeProperty(strategy); var nodeState = new OuterLoopBehaviorState(traceSteps); var target = new BehaviorGraphNode(nodeState); _nodes.Add(target); var newEdge = new BehaviorGraphEdge(source, target, outerEdgeProp); source.OutEdges.Add(newEdge); target.InEdges.Add(newEdge); source = target; } }
//multiple strategy public void Update(IEnumerable <Tuple <object, object> > traces) { Debug.Assert(Nodes[0] != null); BehaviorGraphNode source = Nodes[0]; foreach (var tuple in traces) { var strategy = tuple.Item1 as string; var tsExpr = tuple.Item2 as List <TraceStepExpr>; Debug.Assert(strategy != null); Debug.Assert(tsExpr != null); var traceSteps = tsExpr.Select(tse => tse.TraceStep).ToList(); var outerNode = SearchOuterLoopNode(strategy); if (outerNode == null) { var outerEdgeProp = new OuterLoopEdgeProperty(strategy); var nodeState = new OuterLoopBehaviorState(traceSteps); outerNode = new BehaviorGraphNode(nodeState); _nodes.Add(outerNode); var newEdge = new BehaviorGraphEdge(source, outerNode, outerEdgeProp); source.OutEdges.Add(newEdge); outerNode.InEdges.Add(newEdge); source = outerNode; } else { Update(tsExpr, outerNode); } } }
public int PathFinding(BehaviorGraphNode currentNode) { Debug.Assert(currentNode != null); int count = 0; while (currentNode.OutEdges.Count != 0) { currentNode = currentNode.OutEdges[0].Target; count++; } var parentNode = SearchOuterLoopNode(currentNode); if (parentNode == null) { return(0); } while (parentNode.OutEdges.Count != 0) { parentNode = parentNode.OutEdges[0].Target; count += parentNode.SubGraph.Nodes.Count - 1; //count += CurrentSubGraphPathFinding(parentNode); } return(count); }
private void ConnectTwoNodes(TraceStepExpr tsExpr, BehaviorGraphNode gn1, BehaviorGraphNode gn2) { bool findTarget = false; foreach (var edge in gn1.OutEdges) { if (edge.Target == null) { continue; } if (edge.Target.Equals(gn2)) { findTarget = true; } } if (!findTarget) { InnerLoopEdgeProperty newEdgeProp1; if (tsExpr.TraceStep.WrongStep) { newEdgeProp1 = new InnerLoopEdgeProperty(); } else { newEdgeProp1 = new InnerLoopEdgeProperty((string)tsExpr.TraceStep.Rule, (string)tsExpr.TraceStep.AppliedRule); } var newEdge1 = new BehaviorGraphEdge(gn1, gn2, newEdgeProp1); gn1.OutEdges.Add(newEdge1); gn2.InEdges.Add(newEdge1); } }
private void Update(IEnumerable <TraceStepExpr> steps, BehaviorGraphNode outerLoopNode) { Debug.Assert(outerLoopNode != null); foreach (var step in steps) { Update(step, outerLoopNode); } }
public static bool DeriveToWrongPath(this BehaviorGraphNode innerLoopNode) { foreach (var edge in innerLoopNode.OutEdges) { var edgeProp = edge.Property as InnerLoopEdgeProperty; Debug.Assert(edgeProp != null); if (!edgeProp.CorrectPath) { continue; } return(false); } return(true); }
public bool Match(TraceStepExpr tsExpr) { var ts = tsExpr.TraceStep; Debug.Assert(ts != null); BehaviorGraphNode gn1 = SearchInnerLoopNode(ts.Source); BehaviorGraphNode gn2 = SearchInnerLoopNode(ts.Target); if (gn1 == null && gn2 == null) { return(false); } return(true); }
private List <string> SearchAllOuterEdgeInfos(int index) { var lst = new List <string>(); BehaviorGraphNode currentNode = Nodes[0]; var edgeProp = currentNode.OutEdges[index].Property as OuterLoopEdgeProperty; Debug.Assert(edgeProp != null); lst.Add(edgeProp.Strategy); currentNode = currentNode.OutEdges[index].Target; while (currentNode.OutEdges.Count != 0) { edgeProp = currentNode.OutEdges[0].Property as OuterLoopEdgeProperty; Debug.Assert(edgeProp != null); lst.Add(edgeProp.Strategy); currentNode = currentNode.OutEdges[0].Target; } return(lst); }
public int SearchOuterLoopNodeIndex(BehaviorGraphNode gn) { Debug.Assert(gn.SubGraph == null); var parentNode = SearchOuterLoopNode(gn); BehaviorGraphNode currentNode = Nodes[0]; int index = FindGoalIndex(); var edgeProp = currentNode.OutEdges[index].Property as OuterLoopEdgeProperty; Debug.Assert(edgeProp != null); currentNode = currentNode.OutEdges[index].Target; int counter = 1; if (currentNode.Equals(parentNode)) { return(counter); } while (currentNode.OutEdges.Count != 0) { counter++; edgeProp = currentNode.OutEdges[0].Property as OuterLoopEdgeProperty; Debug.Assert(edgeProp != null); currentNode = currentNode.OutEdges[0].Target; if (currentNode.Equals(parentNode)) { return(counter); } } return(counter); /* for (var i = 0; i < Nodes.Count; i++) * { * if (Nodes[i].Equals(parentNode)) * { * return i; * } * } * return -1;*/ }
//TODO public int CurrentSubGraphPathFinding(BehaviorGraphNode outerLoopNode) { var obj = SearchInnerLoopNode(outerLoopNode); var innerNode = obj as BehaviorGraphNode; var innerNodeLst = obj as List <BehaviorGraphNode>; BehaviorGraphNode sourceNode = null; if (innerNode != null) { sourceNode = innerNode; } if (innerNodeLst != null) { sourceNode = innerNodeLst[0]; } int parentIndex = SearchOuterLoopNodeIndex(sourceNode); int count = 0; while (sourceNode != null && sourceNode.OutEdges.Count != 0) { var nextObj = SearchNextInnerLoopNode(sourceNode); var nextNode = obj as BehaviorGraphNode; var nextNodeLst = obj as List <BehaviorGraphNode>; if (nextNodeLst != null) { nextNode = nextNodeLst[0]; } int outerLoopIndex = SearchOuterLoopNodeIndex(nextNode); if (outerLoopIndex != parentIndex) { break; } count++; } return(count); }
private void InitSubGraph() { var outerState = _state as OuterLoopBehaviorState; if (outerState == null) { return; } var steps = outerState.Traces; if (steps == null || steps.Count == 0) { return; } _subGraph = new BehaviorGraph(); var ts1 = steps[0]; var startState = new BehaviorGraphNode(new InnerLoopBehaviorState(ts1.Source)); _subGraph.Nodes.Add(startState); BehaviorGraphNode source = startState; for (int i = 0; i < outerState.Traces.Count; i++) { var ts = outerState.Traces[i]; var nodeState = new InnerLoopBehaviorState(ts.Target); var target = new BehaviorGraphNode(nodeState); _subGraph.Nodes.Add(target); var innerEdgeProp = new InnerLoopEdgeProperty((string)ts.Rule, (string)ts.AppliedRule); var newEdge = new BehaviorGraphEdge(source, target, innerEdgeProp); source.OutEdges.Add(newEdge); target.InEdges.Add(newEdge); source = target; } }
/// <summary> /// /// </summary> /// <param name="outerNode"></param> /// <returns>BehaviorGraphNode or List<BehaviorGraphNode></returns> public object SearchInnerLoopNode(BehaviorGraphNode outerNode, bool wrongPathFilter = true) { Debug.Assert(outerNode != null); if (outerNode.SubGraph == null || outerNode.SubGraph.Nodes.Count == 0) { return(null); } if (outerNode.SubGraph.Nodes.Count == 1) { return(Nodes[1].SubGraph.Nodes[0]); } var lst = new List <BehaviorGraphNode>(); foreach (BehaviorGraphNode node in outerNode.SubGraph.Nodes) { if (node.InEdges.Count == 0) { if (wrongPathFilter && node.DeriveToWrongPath()) { continue; } lst.Add(node); } } if (lst.Count == 1) { return(lst[0]); } if (lst.Count == 0) { if (outerNode.SubGraph.Nodes.Count != 0) { return(outerNode.SubGraph.Nodes[0]); } } return(lst); }
private void Update(TraceStepExpr tsExpr, BehaviorGraphNode outerLoopNode = null) { var ts = tsExpr.TraceStep; Debug.Assert(ts != null); BehaviorGraphNode gn1 = SearchInnerLoopNode(ts.Source); BehaviorGraphNode gn2 = SearchInnerLoopNode(ts.Target); if (gn1 != null) { if (gn2 != null) { ConnectTwoNodes(tsExpr, gn1, gn2); } else { ConnectPrevNode(tsExpr, gn1); } } else { Debug.Assert(gn1 == null); if (gn2 != null) { ConnectNextNode(tsExpr, gn2); } else { if (outerLoopNode == null) { return; } ConnectRootNode(tsExpr, outerLoopNode); } } }
public int PathFinding(BehaviorGraphNode currentNode) { Debug.Assert(currentNode != null); int count = 0; while (currentNode.OutEdges.Count != 0) { currentNode = currentNode.OutEdges[0].Target; count++; } var parentNode = SearchOuterLoopNode(currentNode); if (parentNode == null) return 0; while (parentNode.OutEdges.Count != 0) { parentNode = parentNode.OutEdges[0].Target; count += parentNode.SubGraph.Nodes.Count-1; //count += CurrentSubGraphPathFinding(parentNode); } return count; }
public int SearchOuterLoopNodeIndex(BehaviorGraphNode gn) { Debug.Assert(gn.SubGraph == null); var parentNode = SearchOuterLoopNode(gn); BehaviorGraphNode currentNode = Nodes[0]; int index = FindGoalIndex(); var edgeProp = currentNode.OutEdges[index].Property as OuterLoopEdgeProperty; Debug.Assert(edgeProp != null); currentNode = currentNode.OutEdges[index].Target; int counter = 1; if (currentNode.Equals(parentNode)) return counter; while (currentNode.OutEdges.Count != 0) { counter++; edgeProp = currentNode.OutEdges[0].Property as OuterLoopEdgeProperty; Debug.Assert(edgeProp != null); currentNode = currentNode.OutEdges[0].Target; if (currentNode.Equals(parentNode)) return counter; } return counter; /* for (var i = 0; i < Nodes.Count; i++) { if (Nodes[i].Equals(parentNode)) { return i; } } return -1;*/ }
private QueryFeedbackState QueryBehaviorGraph(object obj, out string msg, out object output) { msg = null; output = null; if (UserGraph == null) return QueryFeedbackState.QueryFailed; if ( UserGraph.Nodes.Count == 0 || UserGraph.Nodes.Count == 1) { msg = "TODO"; return QueryFeedbackState.QueryFailed; } /* if (!_queryProcessed) { _queryProcessed = true; output = UserGraph.SearchAllOuterEdgeInfos(); msg = AGTutorMessage.InputQuery; return QueryFeedbackState.TutorQueryStarted; }*/ if (obj != null) { return VerifyBehaviorGraph(obj, out msg, out output); } Debug.Assert(obj == null); Debug.Assert(_currentStateNode != null); object edgeInfo = null; BehaviorGraphNode nextNode = null; var nextTuple1 = UserGraph.SearchNextInnerLoopNode(_currentStateNode); if (nextTuple1 == null) // query-end { //partial checking BehaviorGraph.SolvingStatus ss = UserGraph.CheckSolvingStatus(); if (ss == BehaviorGraph.SolvingStatus.Complete) { msg = AGDemonstrationMessage.QueryEnd; return QueryFeedbackState.TutorQueryEnded; } else if (ss == BehaviorGraph.SolvingStatus.Partial) { int nextGoalIndex = UserGraph.FindGoalIndex(); _currentStateNode = UserGraph.RetrieveInitInnerNode(nextGoalIndex); nextTuple1 = UserGraph.SearchNextInnerLoopNode(_currentStateNode); if (nextTuple1 == null) { msg = AGDemonstrationMessage.QueryEnd; return QueryFeedbackState.TutorQueryEnded; } CurrentStepHintRequired = true; } else { msg = AGDemonstrationMessage.QueryEnd; return QueryFeedbackState.TutorQueryEnded; } } #region Path Selection var tuple11 = nextTuple1 as Tuple<object, object>; var tuple11Lst = nextTuple1 as List<Tuple<object, object>>; if (tuple11 != null) { edgeInfo = tuple11.Item1; nextNode = tuple11.Item2 as BehaviorGraphNode; //_currentStateNode = nextNode; } if (tuple11Lst != null) { var tupleTemp = tuple11Lst[0]; edgeInfo = tupleTemp.Item1; nextNode = tupleTemp.Item2 as BehaviorGraphNode; //_currentStateNode = nextNode; } #endregion if (_currentStepHintRequired) { if (edgeInfo != null) { var innerEdgeProp = edgeInfo as InnerLoopEdgeProperty; Debug.Assert(innerEdgeProp != null); msg = AGTutorMessage.QueryIntermediate; _currentStepHintRequired = false; //int parentIndex = UserGraph.SearchOuterLoopNodeIndex(_currentStateNode); int parentIndex = UserGraph.SearchOuterLoopNodeIndex(nextNode); var lst1 = UserGraph.SearchAllOuterEdgeInfos(); var tuple = new Tuple<object, object, object>(innerEdgeProp.MetaRule, lst1, parentIndex); output = tuple; } return QueryFeedbackState.TutorQueryProcessedHint; } Debug.Assert(nextNode != null); _currentStepHintRequired = true; var nodeState = nextNode.State as InnerLoopBehaviorState; Debug.Assert(nodeState != null); var expr = IKnowledgeGenerator.Generate(nodeState.UserKnowledge); var innerEdgeProp1 = edgeInfo as InnerLoopEdgeProperty; Debug.Assert(innerEdgeProp1 != null); var appliedRule = innerEdgeProp1.AppliedRule; //int parentIndex1 = UserGraph.SearchOuterLoopNodeIndex(_currentStateNode); int parentIndex1 = UserGraph.SearchOuterLoopNodeIndex(nextNode); var lst2 = UserGraph.SearchAllOuterEdgeInfos(); output = new Tuple<object, object, object, object>(appliedRule, expr, lst2, parentIndex1); CurrentStateNode = nextNode; return QueryFeedbackState.TutorQueryProcessedAnswer; }
//multiple strategy public void Update(IEnumerable<Tuple<object, object>> traces) { Debug.Assert(Nodes[0] != null); BehaviorGraphNode source = Nodes[0]; foreach (var tuple in traces) { var strategy = tuple.Item1 as string; var tsExpr = tuple.Item2 as List<TraceStepExpr>; Debug.Assert(strategy != null); Debug.Assert(tsExpr != null); var traceSteps = tsExpr.Select(tse => tse.TraceStep).ToList(); var outerNode = SearchOuterLoopNode(strategy); if (outerNode == null) { var outerEdgeProp = new OuterLoopEdgeProperty(strategy); var nodeState = new OuterLoopBehaviorState(traceSteps); outerNode = new BehaviorGraphNode(nodeState); _nodes.Add(outerNode); var newEdge = new BehaviorGraphEdge(source, outerNode, outerEdgeProp); source.OutEdges.Add(newEdge); outerNode.InEdges.Add(newEdge); source = outerNode; } else { Update(tsExpr, outerNode); } } }
private void ConnectRootNode(TraceStepExpr tsExpr, BehaviorGraphNode parentNode) { Debug.Assert(parentNode != null); var newNodeProp1 = new InnerLoopBehaviorState(tsExpr.TraceStep.Source); var newNode1 = new BehaviorGraphNode(newNodeProp1); var newNodeProp2 = new InnerLoopBehaviorState(tsExpr.TraceStep.Target); var newNode2 = new BehaviorGraphNode(newNodeProp2); InnerLoopEdgeProperty newEdgeProp; if (tsExpr.TraceStep.WrongStep) { newEdgeProp = new InnerLoopEdgeProperty(); } else { newEdgeProp = new InnerLoopEdgeProperty((string)tsExpr.TraceStep.Rule, (string)tsExpr.TraceStep.AppliedRule); } var newEdge = new BehaviorGraphEdge(newNode1, newNode2, newEdgeProp); newNode1.OutEdges.Add(newEdge); newNode2.InEdges.Add(newEdge); parentNode.SubGraph.Nodes.Add(newNode1); parentNode.SubGraph.Nodes.Add(newNode2); }
private void ConnectNextNode(TraceStepExpr tsExpr, BehaviorGraphNode gn2) { var newNodeProp = new InnerLoopBehaviorState(tsExpr.TraceStep.Source); var newNode = new BehaviorGraphNode(newNodeProp); InnerLoopEdgeProperty newEdgeProp; if (tsExpr.TraceStep.WrongStep) { newEdgeProp = new InnerLoopEdgeProperty(); } else { newEdgeProp = new InnerLoopEdgeProperty((string)tsExpr.TraceStep.Rule, (string)tsExpr.TraceStep.AppliedRule); } var newEdge = new BehaviorGraphEdge(newNode, gn2, newEdgeProp); /*foreach (var edge in gn2.InEdges) { var prevNode = edge.Source; prevNode.OutEdges.Add(newEdge); }*/ gn2.InEdges.Add(newEdge); newNode.OutEdges.Add(newEdge); BehaviorGraphNode parentNode = SearchOuterLoopNode(gn2); parentNode.SubGraph.Nodes.Add(newNode); }
private void ConnectTwoNodes(TraceStepExpr tsExpr, BehaviorGraphNode gn1, BehaviorGraphNode gn2) { bool findTarget = false; foreach (var edge in gn1.OutEdges) { if (edge.Target == null) continue; if (edge.Target.Equals(gn2)) { findTarget = true; } } if (!findTarget) { InnerLoopEdgeProperty newEdgeProp1; if (tsExpr.TraceStep.WrongStep) { newEdgeProp1 = new InnerLoopEdgeProperty(); } else { newEdgeProp1 = new InnerLoopEdgeProperty((string)tsExpr.TraceStep.Rule, (string)tsExpr.TraceStep.AppliedRule); } var newEdge1 = new BehaviorGraphEdge(gn1, gn2, newEdgeProp1); gn1.OutEdges.Add(newEdge1); gn2.InEdges.Add(newEdge1); } }
public BehaviorGraphNode SearchOuterLoopNode(BehaviorGraphNode inputInnerNode) { var innerState = inputInnerNode.State as InnerLoopBehaviorState; Debug.Assert(innerState != null); Debug.Assert(inputInnerNode.SubGraph == null); foreach (BehaviorGraphNode outerNode in Nodes) { if (outerNode.SubGraph == null) continue; var internalNodes = outerNode.SubGraph.Nodes; foreach (BehaviorGraphNode innerNode in internalNodes) { bool result = innerNode.Equals(inputInnerNode); if (result) return outerNode; } } return null; }
/// <summary> /// It can be in the same outer loop(sub-graph), or come back to /// the previous sub-graph, or even null /// if it is the first inner-loop node /// </summary> /// <param name="gn"></param> /// <param name="wrongPathFilter"></param> /// <returns>BehaviorGraphNode or List<BehaviorGraphNode></returns> public object SearchPrevInnerLoopNode(BehaviorGraphNode gn, bool wrongPathFilter = true) { var innerState = gn.State as InnerLoopBehaviorState; Debug.Assert(innerState != null); Debug.Assert(gn.SubGraph == null); if (gn.InEdges.Count != 0) { if (gn.InEdges.Count == 1) { return(gn.InEdges[0].Source); } Debug.Assert(gn.InEdges.Count > 1); if (wrongPathFilter) { var lst = new List <BehaviorGraphNode>(); foreach (var edge in gn.InEdges) { var edgeInfo = edge.Property as InnerLoopEdgeProperty; Debug.Assert(edgeInfo != null); if (edgeInfo.CorrectPath) { lst.Add(edge.Source); } } if (lst.Count == 1) { return(lst[0]); } return(lst); } else { var lst = new List <BehaviorGraphNode>(); foreach (var edge in gn.InEdges) { var edgeInfo = edge.Property as InnerLoopEdgeProperty; Debug.Assert(edgeInfo != null); lst.Add(edge.Source); } return(lst); } } Debug.Assert(gn.InEdges.Count == 0); BehaviorGraphNode outerLoopNode = SearchOuterLoopNode(gn); if (outerLoopNode == null) { return(null); } if (outerLoopNode.InEdges.Count == 0) { return(null); } if (outerLoopNode.InEdges.Count == 1) { var edge = outerLoopNode.InEdges[0]; var prevOuterLoopNode = edge.Source; return(SearchInnerLoopNode(prevOuterLoopNode)); } if (outerLoopNode.InEdges.Count > 1) { throw new Exception("TODO"); } return(null); }
/// <summary> /// /// </summary> /// <param name="outerNode"></param> /// <returns>BehaviorGraphNode or List<BehaviorGraphNode></returns> public object SearchInnerLoopNode(BehaviorGraphNode outerNode, bool wrongPathFilter = true) { Debug.Assert(outerNode != null); if (outerNode.SubGraph == null || outerNode.SubGraph.Nodes.Count == 0) return null; if (outerNode.SubGraph.Nodes.Count == 1) { return Nodes[1].SubGraph.Nodes[0]; } var lst = new List<BehaviorGraphNode>(); foreach (BehaviorGraphNode node in outerNode.SubGraph.Nodes) { if (node.InEdges.Count == 0) { if (wrongPathFilter && node.DeriveToWrongPath()) continue; lst.Add(node); } } if (lst.Count == 1) return lst[0]; if (lst.Count == 0) { if (outerNode.SubGraph.Nodes.Count != 0) { return outerNode.SubGraph.Nodes[0]; } } return lst; }
/// <summary> /// It can be in the same sub-graph, or the next sub-graph /// or null /// </summary> /// <param name="currentNode"></param> /// <param name="wrongPathFilter"></param> /// <returns>Tuple<InnerLoopEdgeProperty, BehaviorGraphNode> /// List<Tuple<InnerLoopEdgeProperty, BehaviorGraphNode>> /// </returns> public object SearchNextInnerLoopNode(BehaviorGraphNode currentNode) { if (currentNode == null) { return(null); } var innerState = currentNode.State as InnerLoopBehaviorState; Debug.Assert(innerState != null); //must be leaf node Debug.Assert(currentNode.SubGraph == null); if (currentNode.OutEdges.Count != 0) { var lst = new List <Tuple <object, object> >(); foreach (var tempEdge in currentNode.OutEdges) { var tempEdgeInfo = tempEdge.Property as InnerLoopEdgeProperty; Debug.Assert(tempEdgeInfo != null); if (!tempEdgeInfo.CorrectPath) { continue; } lst.Add(new Tuple <object, object>(tempEdgeInfo, tempEdge.Target)); } if (lst.Count == 0) { throw new Exception("Cannot reach here"); } if (lst.Count == 1) { return(lst[0]); } return(lst); } Debug.Assert(currentNode.OutEdges.Count == 0); //find parent node of current node var parentNode = SearchOuterLoopNode(currentNode); Debug.Assert(parentNode != null); if (parentNode.OutEdges.Count == 0) { return(null); } if (parentNode.OutEdges.Count == 1) { var edge = parentNode.OutEdges[0]; BehaviorGraphEdgeProperty edgeInfo = edge.Property; var nextParentNode = edge.Target; object obj = SearchInnerLoopNode(nextParentNode); var node = obj as BehaviorGraphNode; var lstNode = obj as List <BehaviorGraphNode>; if (node != null) { return(SearchNextInnerLoopNode(node)); //return new Tuple<object, object>(edgeInfo, node); } if (lstNode != null) { var lst = new List <Tuple <object, object> >(); foreach (BehaviorGraphNode bgn in lstNode) { return(SearchNextInnerLoopNode(bgn)); //var tuple = new Tuple<object, object>(edgeInfo, bgn) } } } if (parentNode.OutEdges.Count > 1) { throw new Exception("TODO"); } return(null); }
private void Update(IEnumerable<TraceStepExpr> steps, BehaviorGraphNode outerLoopNode) { Debug.Assert(outerLoopNode != null); foreach (var step in steps) { Update(step, outerLoopNode); } }
/// <summary> /// It can be in the same outer loop(sub-graph), or come back to /// the previous sub-graph, or even null /// if it is the first inner-loop node /// </summary> /// <param name="gn"></param> /// <param name="wrongPathFilter"></param> /// <returns>BehaviorGraphNode or List<BehaviorGraphNode></returns> public object SearchPrevInnerLoopNode(BehaviorGraphNode gn, bool wrongPathFilter = true) { var innerState = gn.State as InnerLoopBehaviorState; Debug.Assert(innerState != null); Debug.Assert(gn.SubGraph == null); if (gn.InEdges.Count != 0) { if (gn.InEdges.Count == 1) return gn.InEdges[0].Source; Debug.Assert(gn.InEdges.Count > 1); if (wrongPathFilter) { var lst = new List<BehaviorGraphNode>(); foreach (var edge in gn.InEdges) { var edgeInfo = edge.Property as InnerLoopEdgeProperty; Debug.Assert(edgeInfo != null); if(edgeInfo.CorrectPath) lst.Add(edge.Source); } if (lst.Count == 1) return lst[0]; return lst; } else { var lst = new List<BehaviorGraphNode>(); foreach (var edge in gn.InEdges) { var edgeInfo = edge.Property as InnerLoopEdgeProperty; Debug.Assert(edgeInfo != null); lst.Add(edge.Source); } return lst; } } Debug.Assert(gn.InEdges.Count == 0); BehaviorGraphNode outerLoopNode = SearchOuterLoopNode(gn); if (outerLoopNode == null) return null; if (outerLoopNode.InEdges.Count == 0) return null; if (outerLoopNode.InEdges.Count == 1) { var edge = outerLoopNode.InEdges[0]; var prevOuterLoopNode = edge.Source; return SearchInnerLoopNode(prevOuterLoopNode); } if (outerLoopNode.InEdges.Count > 1) { throw new Exception("TODO"); } return null; }
private void Update(TraceStepExpr tsExpr, BehaviorGraphNode outerLoopNode = null) { var ts = tsExpr.TraceStep; Debug.Assert(ts != null); BehaviorGraphNode gn1 = SearchInnerLoopNode(ts.Source); BehaviorGraphNode gn2 = SearchInnerLoopNode(ts.Target); if (gn1 != null) { if (gn2 != null) { ConnectTwoNodes(tsExpr, gn1, gn2); } else { ConnectPrevNode(tsExpr, gn1); } } else { Debug.Assert(gn1 == null); if (gn2 != null) { ConnectNextNode(tsExpr, gn2); } else { if (outerLoopNode == null) return; ConnectRootNode(tsExpr, outerLoopNode); } } }
/// <summary> /// It can be in the same sub-graph, or the next sub-graph /// or null /// </summary> /// <param name="currentNode"></param> /// <param name="wrongPathFilter"></param> /// <returns>Tuple<InnerLoopEdgeProperty, BehaviorGraphNode> /// List<Tuple<InnerLoopEdgeProperty, BehaviorGraphNode>> /// </returns> public object SearchNextInnerLoopNode(BehaviorGraphNode currentNode) { if (currentNode == null) return null; var innerState = currentNode.State as InnerLoopBehaviorState; Debug.Assert(innerState != null); //must be leaf node Debug.Assert(currentNode.SubGraph == null); if (currentNode.OutEdges.Count != 0) { var lst = new List<Tuple<object, object>>(); foreach (var tempEdge in currentNode.OutEdges) { var tempEdgeInfo = tempEdge.Property as InnerLoopEdgeProperty; Debug.Assert(tempEdgeInfo != null); if (!tempEdgeInfo.CorrectPath) continue; lst.Add(new Tuple<object, object>(tempEdgeInfo, tempEdge.Target)); } if(lst.Count == 0) throw new Exception("Cannot reach here"); if (lst.Count == 1) return lst[0]; return lst; } Debug.Assert(currentNode.OutEdges.Count == 0); //find parent node of current node var parentNode = SearchOuterLoopNode(currentNode); Debug.Assert(parentNode != null); if (parentNode.OutEdges.Count == 0) return null; if (parentNode.OutEdges.Count == 1) { var edge = parentNode.OutEdges[0]; BehaviorGraphEdgeProperty edgeInfo = edge.Property; var nextParentNode = edge.Target; object obj = SearchInnerLoopNode(nextParentNode); var node = obj as BehaviorGraphNode; var lstNode = obj as List<BehaviorGraphNode>; if (node != null) { return SearchNextInnerLoopNode(node); //return new Tuple<object, object>(edgeInfo, node); } if (lstNode != null) { var lst = new List<Tuple<object, object>>(); foreach (BehaviorGraphNode bgn in lstNode) { return SearchNextInnerLoopNode(bgn); //var tuple = new Tuple<object, object>(edgeInfo, bgn) } } } if (parentNode.OutEdges.Count > 1) { throw new Exception("TODO"); } return null; }