/// <summary>
/// Returns a reversed breadth first parent edge iterator.
/// </summary>
/// <param name="treeNode">The tree node.</param>
/// <param name="treeIterationMode">The tree iteration mode.</param>
/// <returns>A reversed breadth first parent edge iterator.</returns>
public static IEnumerable <ITaxonRelationsTreeEdge> AsTopDownBreadthFirstParentEdgeIterator(
this ITaxonRelationsTreeNode treeNode,
TaxonRelationsTreeParentsIterationMode treeIterationMode)
{
return(AsTopDownBreadthFirstParentEdgeIterator(new List <ITaxonRelationsTreeNode> {
treeNode
}, treeIterationMode));
}
/// <summary>
/// Creates an iterator that traverses a tree nodes parents bottom first breadth first.
/// </summary>
public static IEnumerable <ITaxonRelationsTreeNode> AsBottomFirstBreadthFirstParentNodeIterator(
this ITaxonRelationsTreeNode treeNode,
TaxonRelationsTreeParentsIterationMode treeIterationMode,
bool returnStartNode = true)
{
return(AsBottomFirstBreadthFirstParentNodeIterator(new List <ITaxonRelationsTreeNode> {
treeNode
}, treeIterationMode, returnStartNode));
}
/// <summary>
/// Creates an iterator that traverses a tree nodes parents bottom first breadth first.
/// </summary>
public static IEnumerable <ITaxonRelationsTreeNode> AsBottomFirstBreadthFirstParentNodeIterator(
this ICollection <ITaxonRelationsTreeNode> treeNodes,
TaxonRelationsTreeParentsIterationMode treeIterationMode,
bool returnStartNodes = true)
{
HashSet <ITaxonRelationsTreeNode> visitedNodes = new HashSet <ITaxonRelationsTreeNode>();
Queue <ITaxonRelationsTreeNode> queue = new Queue <ITaxonRelationsTreeNode>();
foreach (var treeNode in treeNodes)
{
queue.Enqueue(treeNode);
}
while (queue.Any())
{
ITaxonRelationsTreeNode current = queue.Dequeue();
if (current != null)
{
if (current.ValidMainParents != null)
{
for (int i = current.ValidMainParents.Count - 1; i >= 0; i--)
{
queue.Enqueue(current.ValidMainParents[i].Parent);
}
}
if (treeIterationMode == TaxonRelationsTreeParentsIterationMode.BothValidMainAndSecondaryParents)
{
if (current.ValidSecondaryParents != null)
{
for (int i = current.ValidSecondaryParents.Count - 1; i >= 0; i--)
{
queue.Enqueue(current.ValidSecondaryParents[i].Parent);
}
}
}
// Avoid cycles. Just return not visited nodes.
if (!visitedNodes.Contains(current))
{
visitedNodes.Add(current);
if (returnStartNodes || !treeNodes.Any(x => Equals(x, current)))
{
yield return(current);
}
}
}
}
}
/// <summary>
/// Creates an iterator that traverses a list of tree nodes parents top first.
/// </summary>
public static IEnumerable <ITaxonRelationsTreeEdge> AsTopDownBreadthFirstParentEdgeIterator(
this ICollection <ITaxonRelationsTreeNode> treeNodes,
TaxonRelationsTreeParentsIterationMode treeIterationMode)
{
List <ITaxonRelationsTreeEdge> edges = new List <ITaxonRelationsTreeEdge>();
foreach (var edge in treeNodes.AsBreadthFirstParentEdgeIterator(treeIterationMode))
{
edges.Add(edge);
}
edges.Reverse();
foreach (var edge in edges)
{
yield return(edge);
}
}
/// <summary>
/// Returns a breadth first parent edge iterator.
/// </summary>
/// <param name="treeNodes">The tree nodes.</param>
/// <param name="treeIterationMode">The tree iteration mode.</param>
/// <returns>A breadth first parent edge iterator.</returns>
public static IEnumerable <ITaxonRelationsTreeEdge> AsBreadthFirstParentEdgeIterator(
this ICollection <ITaxonRelationsTreeNode> treeNodes,
TaxonRelationsTreeParentsIterationMode treeIterationMode)
{
List <ITaxonRelationsTreeEdge> edges = new List <ITaxonRelationsTreeEdge>();
if (treeIterationMode == TaxonRelationsTreeParentsIterationMode.Everything)
{
foreach (var treeNode in treeNodes)
{
if (treeNode.AllParentEdges != null)
{
for (int i = treeNode.AllParentEdges.Count - 1; i >= 0; i--)
{
edges.Add(treeNode.AllParentEdges[i]);
}
}
}
return(AsBreadthFirstParentEdgeIterator(edges, treeIterationMode));
}
foreach (var treeNode in treeNodes)
{
if (treeNode.ValidMainParents != null)
{
for (int i = treeNode.ValidMainParents.Count - 1; i >= 0; i--)
{
edges.Add(treeNode.ValidMainParents[i]);
}
}
if (treeIterationMode == TaxonRelationsTreeParentsIterationMode.BothValidMainAndSecondaryParents)
{
if (treeNode.ValidSecondaryParents != null)
{
for (int i = treeNode.ValidSecondaryParents.Count - 1; i >= 0; i--)
{
edges.Add(treeNode.ValidSecondaryParents[i]);
}
}
}
}
return(AsBreadthFirstParentEdgeIterator(edges, treeIterationMode));
}
/// <summary>
/// Creates an iterator that traverses a tree nodes parents top first breadth first.
/// </summary>
public static IEnumerable <ITaxonRelationsTreeNode> AsTopFirstBreadthFirstParentNodeIterator(
this ICollection <ITaxonRelationsTreeNode> treeNodes,
TaxonRelationsTreeParentsIterationMode treeIterationMode,
bool returnStartNodes = true)
{
List <ITaxonRelationsTreeNode> nodes = new List <ITaxonRelationsTreeNode>();
foreach (var node in treeNodes.AsBottomFirstBreadthFirstParentNodeIterator(treeIterationMode))
{
nodes.Add(node);
}
nodes.Reverse();
foreach (var node in nodes)
{
yield return(node);
}
}
/// <summary>
/// Creates an iterator that traverses a list of tree nodes parents top first.
/// </summary>
public static IEnumerable <ITaxonRelationsTreeEdge> AsBreadthFirstParentEdgeIterator(
this ICollection <ITaxonRelationsTreeEdge> treeEdges,
TaxonRelationsTreeParentsIterationMode treeIterationMode)
{
HashSet <ITaxonRelationsTreeNode> visitedNodes = new HashSet <ITaxonRelationsTreeNode>();
HashSet <ITaxonRelationsTreeEdge> visitedEdges = new HashSet <ITaxonRelationsTreeEdge>();
Queue <ITaxonRelationsTreeEdge> queue = new Queue <ITaxonRelationsTreeEdge>();
foreach (ITaxonRelationsTreeEdge edge in treeEdges)
{
visitedNodes.Add(edge.Child);
queue.Enqueue(edge);
}
while (queue.Any())
{
ITaxonRelationsTreeEdge current = queue.Dequeue();
if (current != null)
{
if (treeIterationMode == TaxonRelationsTreeParentsIterationMode.Everything)
{
if (current.Parent.AllParentEdges != null)
{
for (int i = current.Parent.AllParentEdges.Count - 1; i >= 0; i--)
{
queue.Enqueue(current.Parent.AllParentEdges[i]);
}
}
}
else
{
if (current.Parent.ValidMainParents != null)
{
for (int i = current.Parent.ValidMainParents.Count - 1; i >= 0; i--)
{
queue.Enqueue(current.Parent.ValidMainParents[i]);
}
}
if (treeIterationMode == TaxonRelationsTreeParentsIterationMode.BothValidMainAndSecondaryParents)
{
if (current.Parent.ValidSecondaryParents != null)
{
for (int i = current.Parent.ValidSecondaryParents.Count - 1; i >= 0; i--)
{
queue.Enqueue(current.Parent.ValidSecondaryParents[i]);
}
}
}
}
// Avoid cycles. Just return not visited nodes.
if (!visitedNodes.Contains(current.Parent))
{
visitedNodes.Add(current.Parent);
}
// Avoid cycles. Just return not visited edges.
if (!visitedEdges.Contains(current))
{
visitedEdges.Add(current);
yield return(current);
}
}
}
}
