/// <summary>
/// Determine whether there is an edge between given nodes
/// </summary>
/// <param name="node1"></param>
/// <param name="edge"></param>
/// <param name="node2"></param>
/// <returns></returns>
public bool HasEdge(NodeReference node1, string edge, NodeReference node2)
{
foreach (var layer in _layers)
{
var edges = layer.Edges(node1, node2);
if (edges.Contains(edge))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Determine whether node is contained in currrent or previous segments.
/// </summary>
/// <param name="node">Tested node.</param>
/// <returns><c>true</c> whether node is contained, <c>false</c> otherwise.</returns>
internal bool Contains(NodeReference node)
{
if (Node.Equals(node))
{
return(true);
}
if (PreviousSegment == null)
{
return(false);
}
return(PreviousSegment.Contains(node));
}
internal Trace(NodeReference currentNode, IEnumerable <Trace> previousTraces)
{
CurrentNode = currentNode;
PreviousTraces = previousTraces;
var initialNodes = new HashSet <NodeReference>();
foreach (var trace in previousTraces)
{
initialNodes.UnionWith(trace.InitialNodes);
}
InitialNodes = initialNodes.ToArray();
}
private IEnumerable <NodeReference> getTargets(NodeReference node, string edge, Dictionary <NodeReference, Dictionary <string, List <NodeReference> > > edges)
{
Dictionary <string, List <NodeReference> > targetCandidates;
List <NodeReference> targets;
if (
edges.TryGetValue(node, out targetCandidates) &&
targetCandidates.TryGetValue(edge, out targets)
)
{
return(targets);
}
return(Enumerable.Empty <NodeReference>());
}
/// <summary>
/// Edges between given nodes (both side edges).
/// </summary>
/// <param name="node1"></param>
/// <param name="node2"></param>
/// <returns></returns>
public IEnumerable <Edge> BetweenEdges(NodeReference node1, NodeReference node2)
{
foreach (var layer in _layers)
{
foreach (var edge in layer.Edges(node1, node2))
{
yield return(Edge.Outcoming(edge));
}
foreach (var edge in layer.Edges(node2, node1))
{
yield return(Edge.Incoming(edge));
}
}
}
/// <summary>
/// Get children of given node (incoming and outcoming).
/// </summary>
/// <param name="node"></param>
/// <param name="maxWidth"></param>
/// <returns></returns>
public IEnumerable <Tuple <Edge, NodeReference> > GetNeighbours(NodeReference node, int maxWidth)
{
foreach (var layer in _layers)
{
foreach (var pair in layer.Incoming(node).Take(maxWidth))
{
yield return(Tuple.Create(Edge.Incoming(pair.Key), pair.Value));
}
foreach (var pair in layer.Outcoming(node).Take(maxWidth))
{
yield return(Tuple.Create(Edge.Outcoming(pair.Key), pair.Value));
}
}
}
private IEnumerable <KeyValuePair <string, NodeReference> > getEdges(NodeReference node, Dictionary <NodeReference, Dictionary <string, List <NodeReference> > > edges)
{
Dictionary <string, List <NodeReference> > targets;
if (!edges.TryGetValue(node, out targets))
{
yield break;
}
//enumerate all incoming edges
foreach (var targetPair in targets)
{
foreach (var target in targetPair.Value)
{
yield return(new KeyValuePair <string, NodeReference>(targetPair.Key, target));
}
}
}
/// <inheritdoc/>
protected internal override IEnumerable <string> Edges(NodeReference from, NodeReference to)
{
Dictionary <string, List <NodeReference> > targets;
if (!_outEdges.TryGetValue(from, out targets))
{
yield break;
}
//enumerate all edge connections
foreach (var targetPair in targets)
{
if (targetPair.Value.Contains(to))
{
yield return(targetPair.Key);
}
}
}
private void addChildren(NodeReference node, PathSegment previousSegment, ComposedGraph graph)
{
foreach (var edgeTuple in graph.GetNeighbours(node, _maxSearchWidth))
{
var edge = edgeTuple.Item1;
var child = edgeTuple.Item2;
if (previousSegment != null && (previousSegment.Contains(child) || (_distinctEdges && previousSegment.Contains(edge.Name))))
{
//the node has already been visited previously in the path
continue;
}
if (previousSegment.SegmentIndex < _maxSearchDepth)
{
_segmentsToVisit.Enqueue(new PathSegment(previousSegment, edge, child));
}
}
}
private void addEdge(NodeReference from, string edge, NodeReference to, Dictionary <NodeReference, Dictionary <string, List <NodeReference> > > edges)
{
Dictionary <string, List <NodeReference> > edgeNodes;
if (
!edges.TryGetValue(from, out edgeNodes)
)
{
edges[from] = edgeNodes = new Dictionary <string, List <NodeReference> >();
}
List <NodeReference> nodes;
if (
!edgeNodes.TryGetValue(edge, out nodes)
)
{
edgeNodes[edge] = nodes = new List <NodeReference>();
}
nodes.Add(to);
}
abstract internal protected IEnumerable <NodeReference> Outcoming(NodeReference fromNode, string edge);
/// <inheritdoc/>
protected internal override IEnumerable <NodeReference> Outcoming(NodeReference fromNode, string edge)
{
return(getTargets(fromNode, edge, _outEdges));
}
/// <summary>
/// Get paths between given nodes.
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="maxLength"></param>
/// <param name="maxWidth"></param>
/// <returns></returns>
public IEnumerable <KnowledgePath> GetPaths(NodeReference from, NodeReference to, int maxLength, int maxWidth)
{
if (from == null || to == null)
{
yield break;
}
var currentQueue = new Queue <PathSegment>();
var visitedNodes = new HashSet <NodeReference>();
var startSegment = new PathSegment(null, null, from);
if (from.Equals(to))
{
yield return(new KnowledgePath(startSegment));
yield break;
}
//starting node
currentQueue.Enqueue(startSegment);
//delimiter - for counting path length
currentQueue.Enqueue(null);
visitedNodes.Add(from);
visitedNodes.Add(to);
var currentPathLength = 0;
while (currentQueue.Count > 0 && currentPathLength < maxLength)
{
var currentSegment = currentQueue.Dequeue();
if (currentSegment == null)
{
++currentPathLength;
//add next delimiter
currentQueue.Enqueue(null);
continue;
}
//test if we can get into end node
foreach (var edge in BetweenEdges(currentSegment.Node, to))
{
var segment = new PathSegment(currentSegment, edge, to);
yield return(new KnowledgePath(segment));
}
//explore next children
foreach (var childPair in GetNeighbours(currentSegment.Node, maxWidth))
{
var edge = childPair.Item1;
var child = childPair.Item2;
if (!visitedNodes.Add(child))
{
//this node has already been visited
continue;
}
var childSegment = new PathSegment(currentSegment, edge, child);
currentQueue.Enqueue(childSegment);
}
}
}
/// <inheritdoc/>
protected internal override IEnumerable <NodeReference> Incoming(NodeReference toNode, string edge)
{
return(getTargets(toNode, edge, _inEdges));
}
/// <summary>
/// Create new path by prepending given node and edge to current path.
/// </summary>
/// <param name="node"></param>
/// <param name="edge"></param>
/// <param name="isOutcome"></param>
/// <returns></returns>
internal KnowledgePath PrependBy(NodeReference node, Edge edge)
{
return(new KnowledgePath(
new[] { node }.Concat(_nodes),
new[] { edge }.Concat(_edges)));
}
/// <summary>
/// Add edge to the layer.
/// </summary>
/// <param name="from">From node.</param>
/// <param name="edge">Edge between from and to nodes.</param>
/// <param name="to">To node.</param>
public void AddEdge(NodeReference from, string edge, NodeReference to)
{
addEdge(from, edge, to, _outEdges);
addEdge(to, edge, from, _inEdges);
}
internal Trace GetTrace(NodeReference node)
{
return(_traceIndex[node]);
}
/// <summary>
/// Adds node to the pattern.
/// </summary>
/// <param name="node">The node to be added.</param>
public void AddNode(NodeReference node)
{
_groupNodes.Add(node);
}
abstract internal protected IEnumerable <NodeReference> Incoming(NodeReference toNode, string edge);
/// <inheritdoc/>
protected internal override IEnumerable <KeyValuePair <string, NodeReference> > Outcoming(NodeReference node)
{
return(getEdges(node, _outEdges));
}
abstract internal protected IEnumerable <KeyValuePair <string, NodeReference> > Outcoming(NodeReference node);
abstract internal protected IEnumerable <string> Edges(NodeReference from, NodeReference to);
