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);
}
