private void Visit(IReactiveNode currentNode, Dictionary <IReactiveNode, bool> visitedNodes, List <IReactiveNode> sortedNodes) { bool inProcess; var alreadyVisited = visitedNodes.TryGetValue(currentNode, out inProcess); if (alreadyVisited == true) { if (inProcess == true) { throw new Exception("Cyclic dependencies identifier!"); } } else { visitedNodes[currentNode] = true; var successors = currentNode.Successors; foreach (var successor in successors) { Visit(successor, visitedNodes, sortedNodes); } visitedNodes[currentNode] = false; sortedNodes.Add(currentNode); } }
public void RemoveDependency(IReactiveNode predecessor, IReactiveNode successor) { if (predecessor != null && predecessor != null) { predecessor.RemoveSuccessor(successor); successor.RemovePredecessor(predecessor); } }
public void AddPredecessor(IReactiveNode node) { ValidatePredecessor(node); if (Predecessors.Contains(node) == false) { Predecessors.Add(node); } }
public void AddSuccessor(IReactiveNode node) { ValidateSuccessor(node); if (Successors.Contains(node) == false) { Successors.Add(node); } }
private void ValidateSuccessor(IReactiveNode node) { if (node == null) { throw new ArgumentException("Successor cannot be null!"); } if (node == this) { throw new ArgumentException("Node cannot be successor to itself!"); } }
public void AddNode(IReactiveNode node) { if (node == null) { throw new ArgumentException("Cannot add null node!"); } if (Nodes.Contains(node) == false) { Nodes.Add(node); } }
private List <IReactiveNode> Sort(IEnumerable <IReactiveNode> unsortedNodes, IReactiveNode initialNode) { var sorted = new List <IReactiveNode>(); var visited = new Dictionary <IReactiveNode, bool>(); if (unsortedNodes.Contains(initialNode)) { Visit(initialNode, visited, sorted); } sorted.Reverse(); return(sorted); }
public void PerformUpdate(IReactiveNode initialNode) { try { OnUpdateStarted(); var sortedNodes = Sort(Nodes, initialNode); UpdateNodes(sortedNodes); OnUpdateSuccessful(); } catch (Exception) { OnUpdateFailed(); } }
private void ValidateDependency(IReactiveNode predecessor, IReactiveNode successor) { if (predecessor == null) { throw new ArgumentException("Predecessor node cannot be null!"); } if (successor == null) { throw new ArgumentException("Successor node cannot be null!"); } if (predecessor == successor) { throw new ArgumentException("Predecessor and successor cannot be the node!"); } }
public void CreateDependency(IReactiveNode predecessor, IReactiveNode successor) { ValidateDependency(predecessor, successor); if (Nodes.Contains(predecessor) == false) { Nodes.Add(predecessor); } if (Nodes.Contains(successor) == false) { Nodes.Add(successor); } predecessor.AddSuccessor(successor); successor.AddPredecessor(predecessor); }
public void RemoveNode(IReactiveNode node) { Nodes.Remove(node); }
public void RemoveSuccessor(IReactiveNode node) { Successors.Remove(node); }
public void RemovePredecessor(IReactiveNode node) { Predecessors.Remove(node); }