public static IEnumerable <TNode> Flatten <TNode>(
[NotNull] this IEnumerable <TNode> source,
[NotNull] Func <TNode, IEnumerable <TNode> > childrenSelector,
TreeTraversalMode traversalMode)
{
return(source.Flatten(childrenSelector, traversalMode, (x, _) => x));
}
/// <summary>
/// A helper method to generalize the common steps of binary tree
/// traversal and demo output.
/// </summary>
/// <param name="caption">
/// The title of the traversal that is being performed.
/// </param>
/// <param name="traversalMode">
/// The algorithm to use for traversing the tree.
/// </param>
private static void BinaryTreeTraversalDemo(string caption, TreeTraversalMode traversalMode)
{
var captionUpper = caption.ToUpper();
var captionCapitalized = captionUpper.First() + caption.ToLower().Substring(1);
WriteLine($"BINARY TREE {captionUpper} TRAVERSAL DEMO");
WriteLine();
var tree = CreateBookSampleBinaryTree();
WriteLine(tree);
WriteLine();
WriteLine($"{captionCapitalized} traversal:");
WriteLine();
var traverse = tree.Root.Traverse(traversalMode);
var orderIndex = 0;
foreach (var node in traverse)
{
++orderIndex;
WriteLine($"#{orderIndex}: {node.Data} ({node.GetTreeNodeTypeDescriptor()})");
}
WriteLine();
}
public static IEnumerable <TResult> Flatten <TNode, TResult>(
[NotNull] this IEnumerable <TNode> source,
[NotNull] Func <TNode, IEnumerable <TNode> > childrenSelector,
TreeTraversalMode traversalMode,
[NotNull] Func <TNode, TResult> resultSelector)
{
resultSelector.CheckArgumentNull(nameof(resultSelector));
return(source.Flatten(childrenSelector, traversalMode, (x, _) => resultSelector(x)));
}
/// <summary>
/// Provides flexible routine for traversing all descendants of this instance that match the provided predicate.
/// </summary>
/// <param name="predicate">The predicate that defines the match criteria.</param>
/// <param name="traverseMode">The mode used to traverse the subtree.</param>
public IEnumerable <Node> EnumDescendants(Predicate <Node> predicate, TreeTraversalMode traverseMode)
{
switch (traverseMode)
{
case TreeTraversalMode.BreadthFirst:
Queue <Element> children = new Queue <Element>();
children.Enqueue(this);
while (children.Count > 0)
{
Element childElement = children.Dequeue();
foreach (Node nestedChild in childElement.children)
{
if (predicate == null)
{
yield return(nestedChild);
}
else if (predicate(nestedChild))
{
yield return(nestedChild);
}
Element nestedChildElement = nestedChild as Element;
if (nestedChildElement != null)
{
children.Enqueue(nestedChildElement);
}
}
}
break;
default:
foreach (Node child in this.children)
{
if (predicate == null)
{
yield return(child);
}
else if (predicate(child))
{
yield return(child);
}
Element childElement = child as Element;
if (childElement != null)
{
childElement.EnumDescendants(predicate, traverseMode);
}
}
break;
}
}
public void Enumeration_ThrowsExceptionOnRemove(TreeTraversalMode mode)
{
var tree = Create <int, int>();
tree.Add(1, 1);
using (var enumerator = tree.GetEnumerator(mode))
{
enumerator.MoveNext();
tree.Remove(1);
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
}
}
public IEnumerable <StylesheetTreeNode> EnumChildNodes(TreeTraversalMode traverseMode, bool includeSelf)
{
if (includeSelf)
{
yield return(this);
}
if (traverseMode == TreeTraversalMode.BreadthFirst)
{
Queue <StylesheetTreeNode> children = new Queue <StylesheetTreeNode>();
children.Enqueue(this);
while (children.Count > 0)
{
StylesheetTreeNode child = children.Dequeue();
foreach (StylesheetTreeNode nestedChild in child.Nodes)
{
yield return(nestedChild);
children.Enqueue(nestedChild);
}
}
}
else
{
Stack <StylesheetTreeNode> children = new Stack <StylesheetTreeNode>();
children.Push(this);
while (children.Count > 0)
{
StylesheetTreeNode child = children.Pop();
foreach (StylesheetTreeNode nestedChild in child.Nodes)
{
yield return(nestedChild);
children.Push(nestedChild);
}
}
}
}
/// <summary>
/// Flattens the specified enumerable to every item available.
/// </summary>
/// <typeparam name="TElem">The type of the item in the enumerable.</typeparam>
/// <param name="source">The enumerable to flatten.</param>
/// <param name="provider">The enumerable provider from the item.</param>
/// <param name="mode">The flattening mode.</param>
/// <returns>A lazy enumerable</returns>
public static IEnumerable <TElem> Flatten <TElem>(
this IEnumerable <TElem> source,
Func <TElem, IEnumerable <TElem> > provider,
TreeTraversalMode mode = TreeTraversalMode.Depth)
{
source.CheckArgumentNull(nameof(source));
provider.CheckArgumentNull(nameof(provider));
switch (mode)
{
case TreeTraversalMode.Depth:
foreach (var item in source)
{
yield return(item);
foreach (var subItem in provider(item)
.Flatten(provider, mode))
{
yield return(subItem);
}
}
break;
case TreeTraversalMode.Breadth:
foreach (var item in source)
{
yield return(item);
}
foreach (var item in source)
{
foreach (var subItem in provider(item)
.Flatten(provider, mode))
{
yield return(subItem);
}
}
break;
}
}
public static IEnumerable <TResult> Flatten <TNode, TResult>(
[NotNull] this IEnumerable <TNode> source,
[NotNull] Func <TNode, IEnumerable <TNode> > childrenSelector,
TreeTraversalMode traversalMode,
[NotNull] Func <TNode, int, TResult> resultSelector)
{
source.CheckArgumentNull(nameof(source));
childrenSelector.CheckArgumentNull(nameof(childrenSelector));
resultSelector.CheckArgumentNull(nameof(resultSelector));
switch (traversalMode)
{
case TreeTraversalMode.DepthFirst:
return(source.DepthFirstFlattenIterator(childrenSelector, resultSelector));
case TreeTraversalMode.BreadthFirst:
return(source.BreadthFirstFlattenIterator(childrenSelector, resultSelector));
default:
throw new ArgumentOutOfRangeException(nameof(traversalMode));
}
}
/// <summary>
/// Provides flexible routine for traversing all descendants of this instance.
/// </summary>
/// <param name="traverseMode">The mode used to traverse the subtree.</param>
public IEnumerable <Node> EnumDescendants(TreeTraversalMode traverseMode)
{
return(this.EnumDescendants(null, traverseMode));
}
/// <summary>
/// Returns a lazily evaluated iterator that allows linear iteration
/// over a tree of DependencyObjects.
/// </summary>
/// <param name="parent">The root element of the tree to iterate over.</param>
/// <param name="condition">A predicate to filter what elements are returned.</param>
/// <param name="mode">The tree traversal mode of the iteration algorithm.</param>
/// <returns>
/// A lazily evaluated iterator that allows linear iteration
/// over a tree of DependencyObjects.
/// </returns>
public static IEnumerable <DependencyObject> EnumVisualDescendants(DependencyObject parent, Predicate <DependencyObject> condition = null, TreeTraversalMode mode = TreeTraversalMode.BreadthFirst)
{
if (parent == null)
{
return(null);
}
if (condition == null)
{
condition = (unused) => { return(true); };
}
if (mode == TreeTraversalMode.BreadthFirst)
{
return(EnumVisualDescendantBreadthFirst(parent, condition));
}
return(EnumVisualDescendantDepthFirst(parent, condition));
}
/// <summary>
/// Flattens the specified enumerable which every item in itself is an enumerable.
/// </summary>
/// <typeparam name="TElem">The type of the item in the enumerable.</typeparam>
/// <param name="source">The enumerable to flatten.</param>
/// <param name="mode">The flattening mode.</param>
/// <returns>A lazy enumerable</returns>
public static IEnumerable <TElem> Flatten <TElem>(
this IEnumerable <TElem> source,
TreeTraversalMode mode = TreeTraversalMode.Depth)
where TElem : IEnumerable <TElem>
=> source.Flatten(c => c, mode);
