public IEnumerable <Node <T> > Traverse(TraverseType type = TraverseType.Direct)
{
var enumerator = TraverseEnumerator(type);
while (enumerator.MoveNext())
{
yield return((Node <T>)enumerator.Current);
}
}
private IEnumerator TraverseEnumerator(TraverseType type = TraverseType.Direct)
{
switch (type)
{
case TraverseType.Direct: return(new BinarySearchTreeDirectIterator <T>(this));
case TraverseType.Transverse: return(new BinarySearchTreeTransverseIterator <T>(this));
case TraverseType.Reverse: return(new BinarySearchTreeReverseIterator <T>(this));
default: return(new BinarySearchTreeDirectIterator <T>(this));
}
}
public static IEnumerable <T> Traverse <T>(this T root, TraverseType traverseType)
where T : ITreeNode <T>
{
switch (traverseType)
{
case TraverseType.PreOrder:
return(root.PreOrderTraverse());
case TraverseType.Ancestors:
return(root.AncestorsTraverse());
default:
throw new NotSupportedException(traverseType.ToString());
}
}
public void Traversal(TraverseType tt)
{
if (tt == TraverseType.InOrder)
{
if (_root != null)
{
InOrderTraversal(_root);
}
}
else if (tt == TraverseType.Reverse)
{
if (_root != null)
{
ReverseTraversal(_root);
}
}
}
public IEnumerable <T> Traverse(TraverseType t)
{
IEnumerable <T> structure = null;
switch (t)
{
case TraverseType.InOrder: structure = InOrder(); break;
case TraverseType.PreOrder: structure = PreOrder(); break;
case TraverseType.PostOrder: structure = PostOrder(); break;
}
foreach (T data in structure)
{
yield return(data);
}
}
public FixupTraverser(TraverseType tt)
{
switch (tt)
{
case TraverseType.Modifiers:
ConsiderPair = ConsiderPairModifiers;
break;
case TraverseType.Spacing:
ConsiderPair = ConsiderPairSpacing;
break;
case TraverseType.TType:
ConsiderPair = ConsiderPairTType;
break;
}
_traverseType = tt;
}
/// <summary>
/// Makes tree traversal
/// </summary>
/// <param name="traverseType"><see cref="TraverseType"></param>
/// <returns>Sequense of elements of tree according to traverse type</returns>
public IEnumerable <T> Traverse(TraverseType traverseType)
{
var list = new List <T>();
if (traverseType == TraverseType.InOrder)
{
TraverseInOrder(_head, list);
return(list);
}
else if (traverseType == TraverseType.PostOrder)
{
TraversePostOrder(_head, list);
return(list);
}
else
{
TraversePreOrder(_head, list);
}
return(list);
}
public virtual T[] Traverse(TraverseType traverseType)
{
switch (traverseType)
{
case TraverseType.PreOrder:
PreOrderTraverse(root, d => cachedBuffer.Add(d.Data));
break;
case TraverseType.InOrder:
InOrderTraverse(root, d => cachedBuffer.Add(d.Data));
break;
case TraverseType.PostOrder:
PostOrderTraverse(root, d => cachedBuffer.Add(d.Data));
break;
}
T[] result = cachedBuffer.ToArray();
ClearCache();
return(result);
}
public static void Traverse(TraverseType type, TreeNode root, Action <TreeNode> callback)
{
switch (type)
{
case TraverseType.Pre:
TraverseDFSPre(root, callback);
break;
case TraverseType.In:
TraverseDFSIn(root, callback);
break;
case TraverseType.Post:
TraverseDFSPost(root, callback);
break;
case TraverseType.Level:
TraverseBFS(root, callback);
break;
}
}
public List <T> Traverse(TraverseType traverseType)
{
List <T> result = new List <T>();
if (traverseType == TraverseType.PreOrder)
{
this.PreOrder(this.Root, result);
}
else if (traverseType == TraverseType.InOrder)
{
this.InOrder(this.Root, result);
}
else if (traverseType == TraverseType.PostOrder)
{
this.PostOrder(this.Root, result);
}
else if (traverseType == TraverseType.LevelOrder)
{
this.LevelOrder(this.Root, result);
}
return(result);
}
/// <summary>
/// Makes tree traversal
/// </summary>
/// <param name="traverseType"><see cref="TraverseType"></param>
/// <returns>Sequense of elements of tree according to traverse type</returns>
public IEnumerable <T> Traverse(TraverseType traverseType)
{
Func <Node <T>, IEnumerable <T> > traverseDelegate;
switch (traverseType)
{
default:
traverseDelegate = TraverseInOrder;
break;
case TraverseType.PreOrder:
traverseDelegate = TraversePreOrder;
break;
case TraverseType.PostOrder:
traverseDelegate = TraversePostOrder;
break;
}
foreach (T t in traverseDelegate.Invoke(Root))
{
yield return(t);
}
}
public Input(string s, TraverseType traverseType)
{
tree = Helfer.AssembleBTree(s);
this.traverseType = traverseType;
}
public bool Traverse(TraverseType typeOfTraversal, HandleFolder folderHandler)
{
bool traverseResult = false;
if (Ready)
{
switch (typeOfTraversal)
{
case TraverseType.PreOrder:
PreOrderTraverse(folderHandler, root);
traverseResult = true;
break;
case TraverseType.PostOrder:
PostOrderTraverse(folderHandler, root);
traverseResult = true;
break;
}
}
return traverseResult;
}
public bool Traverse(TraverseType typeOfTraversal, HandleFile fileHandler)
{
bool traverseResult = false;
if (Ready)
{
switch (typeOfTraversal)
{
case TraverseType.PreOrder:
foreach (FileNode file in root.Files)
{
fileHandler(file);
}
PreOrderTraverse(fileHandler, root);
traverseResult = true;
break;
case TraverseType.PostOrder:
PostOrderTraverse(fileHandler, root);
foreach (FileNode file in root.Files)
{
fileHandler(file);
}
traverseResult = true;
break;
}
}
return traverseResult;
}
public Node TraverseSibling(TraverseType type, Node currentnode)
{
// To traverse siblings of type type run these steps:
//Let node be the value of the currentNode attribute.
var node = currentnode;
//If node is root, return null.
if (node.Equals(this.root))
{
return(null);
}
Node sibling;
//Run these substeps:
substeps:
//Let sibling be node's next sibling if type is next, and node's previous sibling if type is previous.
if (type == TraverseType.Next)
{
sibling = node.nextSibling();
}
else if (type == TraverseType.Previous)
{
sibling = node.previousSibling();
}
else
{
// will not run.
sibling = null;
}
//While sibling is not null, run these subsubsteps:
if (sibling != null)
{
//Set node to sibling.
node = sibling;
//Filter node and let result be the return value.
var result = this.FilterNode(node);
//If result is FILTER_ACCEPT, then set the currentNode attribute to node and return node.
if (result == enumNodeFilterAcceptNode.FILTER_ACCEPT)
{
this.currentNode = node;
return(node);
}
else if (result == enumNodeFilterAcceptNode.FILTER_SKIP)
{
//Set sibling to node's first child if type is next, and node's last child if type is previous.
if (type == TraverseType.Next)
{
sibling = node.firstChild();
}
else if (type == TraverseType.Previous)
{
sibling = node.lastChild();
}
}
if (result == enumNodeFilterAcceptNode.FILTER_REJECT || sibling == null)
{
//If result is FILTER_REJECT or sibling is null, then set sibling to node's next sibling if type is next, and node's previous sibling if type is previous.
if (type == TraverseType.Next)
{
sibling = node.nextSibling();
}
else if (type == TraverseType.Previous)
{
sibling = node.previousSibling();
}
}
}
node = node.parentNode;
//Set node to its parent.
//If node is null or is root, return null.
if (node == null || node.Equals(this.root))
{
return(null);
}
//Filter node and if the return value is FILTER_ACCEPT, then return null.
if (this.FilterNode(node) == enumNodeFilterAcceptNode.FILTER_ACCEPT)
{
return(null);
}
//Run these substeps again.
goto substeps;
}
// Method will return any time the state of the sync progress becomes cancelled.
private static void TraverseFolderHelper(FolderCompareObject folder, int numOfPaths, IVisitor visitor, TraverseType type, Progress syncProgress)
{
if (syncProgress != null && syncProgress.State == SyncState.Cancelled)
return;
if (type == TraverseType.Pre)
visitor.Visit(folder, numOfPaths);
Dictionary<string, BaseCompareObject>.ValueCollection values = folder.Contents.Values;
foreach (BaseCompareObject o in values)
{
if (syncProgress != null && syncProgress.State == SyncState.Cancelled)
return;
FolderCompareObject fco;
if ((fco = o as FolderCompareObject) != null)
TraverseFolderHelper(fco, numOfPaths, visitor, type, syncProgress);
else
visitor.Visit(o as FileCompareObject, numOfPaths);
}
if (type == TraverseType.Post)
visitor.Visit(folder, numOfPaths);
}
public Node TraverseChildren(TraverseType type, Node currentnode)
{
//To traverse children of type type, run these steps:
//Let node be the value of the currentNode attribute.
var node = currentnode;
//Set node to node's first child if type is first, and node's last child if type is last.
if (type == TraverseType.First && node.childNodes.item.Count > 0)
{
node = node.childNodes.item[0];
}
else if (type == TraverseType.Last && node.childNodes.item.Count > 0)
{
int count = node.childNodes.item.Count;
node = node.childNodes.item[count - 1];
}
else
{
node = null;
}
//Main: While node is not null, run these substeps:
main:
if (node != null)
{
//Filter node and let result be the return value.
var result = FilterNode(node);
//If result is FILTER_ACCEPT, then set the currentNode attribute to node and return node.
if (result == enumNodeFilterAcceptNode.FILTER_ACCEPT)
{
this.currentNode = node;
return(node);
}
//If result is FILTER_SKIP, run these subsubsteps:
else if (result == enumNodeFilterAcceptNode.FILTER_SKIP)
{
//Let child be node's first child if type is first, and node's last child if type is last.
Node child;
if (type == TraverseType.First && node.childNodes.item.Count > 0)
{
child = node.childNodes.item[0];
}
else if (type == TraverseType.Last && node.childNodes.item.Count > 0)
{
int count = node.childNodes.item.Count;
child = node.childNodes.item[count - 1];
}
else
{
child = null;
}
//If child is not null, set node to child and goto Main.
if (child != null)
{
node = child;
goto main;
}
}
//While node is not null, run these subsubsteps:
if (node != null)
{
//Let sibling be node's next sibling if type is first, and node's previous sibling if type is last.
var sibling = this.nextSibling(node);
//If sibling is not null, set node to sibling and goto Main.
if (sibling != null)
{
node = sibling;
goto main;
}
//Let parent be node's parent.
var parent = node.parentNode;
//If parent is null, parent is root, or parent is currentNode attribute's value, return null.
if (parent == null || parent.Equals(this.root) || parent.Equals(this.currentNode))
{
return(null);
}
else
{
//Otherwise, set node to parent.
node = parent;
}
}
}
//Return null.
return(null);
}
public StringBuilder Traverse(TraverseType TypeOfTraverse)
{
StringBuilder NodeValues = new StringBuilder();
if (!IsEmpty)
{
switch (TypeOfTraverse)
{
case TraverseType.InOrder:
InOrder(root, NodeValues);
break;
case TraverseType.PreOrder:
PreOrder(root, NodeValues);
break;
case TraverseType.PostOrder:
PostOrder(root, NodeValues);
break;
default:
break;
}
}
return NodeValues;
}
public int[] GetValues(TraverseType TypeOfTraverse)
{
int[] NodeValues = new int[Count];
if (!IsEmpty)
{
switch (TypeOfTraverse)
{
case TraverseType.InOrder:
InOrder(root, NodeValues, 0);
break;
case TraverseType.PreOrder:
PreOrder(root, NodeValues, 0);
break;
case TraverseType.PostOrder:
PostOrder(root, NodeValues, 0);
break;
default:
break;
}
}
return NodeValues;
}
