// Changed the get path method public List<Edge> GetPath(Node target) { var path = new List<Edge>(); var node = target; var containsKey = Distance.ContainsKey(node); if (!containsKey) { return null; } path.Add(GetEdgeFromNodes(Predecessors[node], node)); while (Predecessors[node] != null) { node = Predecessors[node]; var isFinished = Predecessors.ContainsKey(node); if (!isFinished) { break; } path.Add(GetEdgeFromNodes(Predecessors[node], node)); } path.Reverse(); return path; }
/// <summary> /// Vorwärtsterminierung. Berechnet den frühesten Anfangs- und Endzeitpunkt des Vorgangs. /// </summary> internal void ForwardPassCalculation() { EarliestStartingPoint = IsInitial ? 0 : Predecessors.Select(pre => pre.EarliestFinishingPoint).Max(); EarliestFinishingPoint = EarliestStartingPoint + Duration; }
public void AddPredecessor(IReactiveNode node) { ValidatePredecessor(node); if (Predecessors.Contains(node) == false) { Predecessors.Add(node); } }
/// <summary> /// Erzeugt eine textuelle Repräsentation des Vorgangs. Angelehnt an die Syntax des Prozessplans. /// </summary> /// <returns>Textuelle Repräsentation des Vorgangs.</returns> internal string GetInfo() { string predecessors = String.Join(",", Predecessors.Select(n => n.ID)); string ancestors = String.Join(",", Successors.Select(n => n.ID)); predecessors = String.IsNullOrWhiteSpace(predecessors) ? "-" : predecessors; ancestors = String.IsNullOrWhiteSpace(ancestors) ? "-" : ancestors; return($"{ID} | {Description} | {Duration} | {predecessors} | {ancestors}"); }
public MessageMemento GetMemento() { return(new MessageMemento() { Hash = Hash.ToString(), MessageType = Type, Predecessors = Predecessors .Select(p => p.ToString()) .ToList(), ObjectId = ObjectId, Body = Body }); }
private void FindShortestDistance(Node node) { var adjNodes = GetNeighbors(node); foreach (var target in adjNodes) { if (GetShortestDistance(target) > GetShortestDistance(node) + GetDistance(node, target)) { Distance.Add(target, GetShortestDistance(node) + GetDistance(node, target)); Predecessors.Add(target, node); UnSettledNodes.Add(target); } } }
public bool Activate(bool activateDependencies) { if (MissingDependencies.Count > 0) { return(false); } if (IsActive) { return(true); } //check whether all predececcors are active -> actual plugin depends on if (activateDependencies) { //try to activate depend plugins if (Predecessors.Count(elem => !((PluginNode)elem).Activate(true)) > 0) { return(false); } } else { //just count inactive plugins if (Predecessors.Count(elem => !((PluginNode)elem).IsActive) > 0) { return(false); } } PluginInstance = Graph.PluginManager.CreatePluginInstance(Value); if (PluginInstance == null) { return(false); } Graph.NotifyPlugins(PluginInstance, PluginNotification.Created); PluginContext = Graph.PluginManager.CreatePluginContext(PluginInstance); PluginInstance.ActivatePlugin(PluginContext); IsActive = true; Graph.NotifyPlugins(PluginInstance, PluginNotification.Activated); return(true); }
/// <summary> /// Returns the path leading to the vertex v. /// </summary> /// <param name="v">end of the path</param> /// <returns>path leading to v</returns> public EdgeCollection Path(IVertex v) { EdgeCollection path = new EdgeCollection(); IVertex vc = v; while (Predecessors.Contains(v)) { IEdge e = Predecessors[v]; path.Insert(0, e); v = e.Source; } return(path); }
/// <summary> /// Unbinds all predecessors and successors from this node. /// </summary> internal void UnBindAll() { while (Predecessors.Count > 0) { FlowNode <T> pre = Predecessors.First(); pre.Successors.Remove(this); Predecessors.Remove(pre); } while (Successors.Count > 0) { FlowNode <T> succ = Successors.First(); succ.Predecessors.Remove(this); Successors.Remove(succ); } //System.Diagnostics.Debug.Assert(DebugConsistencyCheck(pred, succ)); }
public bool Deactivate(bool deactivateDependencies) { if (!IsActive) { return(true); } //check all successors -> these are the ones which depends on actual plugin if (deactivateDependencies) { //try to activate depend plugins if (Predecessors.Count(elem => !((PluginNode)elem).Deactivate(true)) > 0) { return(false); } } else { //just count active plugins if (Predecessors.Count(elem => ((PluginNode)elem).IsActive) > 0) { return(false); } } PluginInstance.DeactivatePlugin(PluginContext); IsActive = false; Graph.NotifyPlugins(PluginInstance, PluginNotification.Deactivated); PluginInstance.Dispose(); Graph.NotifyPlugins(PluginInstance, PluginNotification.Disposed); PluginInstance = null; PluginContext = null; return(true); }
//public virtual void RecalcDuration() //{ // if (Children != null && Children.Where(c => c.Deleted == Core.DomainModel.BaseStatusDeleted.None).Any()) // Duration = Children.Where(c => c.Deleted == Core.DomainModel.BaseStatusDeleted.None).Select(c=>c.Duration).Sum(); // if (Parent == null) // Project.RecalcDuration(); // else // Parent.RecalcDuration(); //} private String PredecessorsToIdString() { return(String.Join(";", Predecessors.Where(p => p.Target != null).OrderBy(p => p.Target.Id).Select(p => p.Target.Id.ToString() + p.Type.ToString() + p.LeadLag.ToString()).ToList())); }
public void RemovePredecessor(IReactiveNode node) { Predecessors.Remove(node); }
public void Validate() { if (RefSuccessors.Count > 0) { throw new ValidatorException("Basic block contains a reference to successors that could not be resolved. Basic block: " + ID); } if (RefPredecessors.Count > 0) { throw new ValidatorException("Basic block contains a reference to successors that could not be resolved. Basic block: " + ID); } if (Instructions.Last().statementType == Common.StatementType.ConditionalJump && Successors.Count != 2) { throw new ValidatorException("Basic block with ConditionalJump statement type must have exactly 2 successors."); } if (Predecessors.Count == 0 && Successors.Count == 0) { throw new ValidatorException("No predecessors and no successors found for basic block " + ID); } if (Instructions.Count == 0) { throw new ValidatorException("No instructions found for basic block " + ID); } if (Successors.Count > 2) { throw new ValidatorException("More than two successors found in basic block " + ID); } if (Predecessors.Count == 0 && !parent.BasicBlocks.First().Equals(this)) { throw new ValidatorException("No predecessors found at basic block " + ID + ". By convention, only the first basic block has empty Predecessors list."); } if (Successors.Count == 0 && (Instructions.Count != 1 || Instructions[0].TACtext != "return")) { throw new ValidatorException("No successors found at basic block " + ID + ". By convention, only the 'fake exit block' has empty Successors list."); } if (Successors.Count == 2) { if (Instructions.Last().statementType != Common.StatementType.ConditionalJump) { throw new ValidatorException("To have 2 successors, the last instruction of a basic block must be a ConditionalJump. Basic block: " + ID); } string resultString = Regex.Match(Instructions.Last().TACtext, @"\bID_[A-F0-9]{8}(?:-[A-F0-9]{4}){3}-[A-F0-9]{12}\b").Value; if (!resultString.Equals(Successors[0].ID)) { throw new ValidatorException("The first successor ID does not match the GOTO instruction. Basic block: " + ID); } } if (Predecessors.Count > 1 && Successors.Count > 0) { int preds_goto = Predecessors.Count(x => (x.Instructions.Last().statementType == Common.StatementType.ConditionalJump && this.Equals(x.getSuccessors.First())) || x.Instructions.Last().statementType == Common.StatementType.UnconditionalJump); if (Predecessors.Count - preds_goto > 1) { throw new ValidatorException("Basic block has more that one direct predecessor (without GOTO). Basic block: " + ID); } } if (Successors.Count == 0) { int preds_proc = Predecessors.Count(x => x.Instructions.Last().statementType == Common.StatementType.Procedural); if (Predecessors.Count - preds_proc > 0) { throw new ValidatorException("The 'fake exit block' can only have predecessors with last 'return' statement. Basic block: " + ID); } } // If a basic block has one predecessor, then it should be a direct predecessor without goto //if(Predecessors.Count==1 && Predecessors[0].Instructions.Last().statementType == Common.StatementType.UnconditionalJump) // throw new ValidatorException("A basic block: " + ID + " has a single direct predecessor with unconditional GOTO."); // Checking Successor-Predecessor links foreach (BasicBlock succ in Successors) { if (!succ.Predecessors.Contains(this) && succ.RefPredecessors.Count == 0) { throw new ValidatorException("Broken successor-predecessor link in basic block " + ID); } } foreach (BasicBlock pred in Predecessors) { if (!pred.Successors.Contains(this) && pred.RefSuccessors.Count == 0) { throw new ValidatorException("Broken predecessor-successor link in basic block " + ID); } } foreach (Instruction inst in this.Instructions) { if (inst.parent != this) { throw new ValidatorException("Instruction's 'parent' property is incorrect. Instruction: " + inst.ID); } inst.Validate(); } }
public override string ToString() { return($"{Id} P:[{string.Join(",", Predecessors.Select(p => p.Id))}] S:[{string.Join(",", Successors.Select(s => s.Id))}]"); }