private void Traversal(TraversalType typ, BSNode node)
{
if (node == null)
{
return;
}
switch (typ)
{
case TraversalType.Front: //前序遍历 ：中—>左—>右
Console.Write(node.Data + " ");
Traversal(typ, node.LeftChild);
Traversal(typ, node.RightChild);
break;
case TraversalType.Middle: //中序遍历：左—>中—>右
Traversal(typ, node.LeftChild);
Console.Write(node.Data + " ");
Traversal(typ, node.RightChild);
break;
case TraversalType.Back: //左—> 右—> 中
Traversal(typ, node.LeftChild);
Traversal(typ, node.RightChild);
Console.Write(node.Data + " ");
break;
default:
break;
}
}
public IList <T> TraverseToList(TraversalType type)
{
LinkedList <T> list = new LinkedList <T>(); //change this to a user defined type of list
if (this.Empty) // if the tree is empty, return an empty list
{
return(list);
}
switch (type)
{
case TraversalType.Inorder:
this.ToInorder(this.Root, list);
break;
case TraversalType.Postorder:
this.ToPostorder(this.Root, list);
break;
case TraversalType.Preorder:
this.ToPreorder(this.Root, list);
break;
case TraversalType.BreadthFirst:
this.ToBreadthFirst(this.Root, list);
break;
}
return(list);
}
private bool Solve(string selectedAlgorithm)
{
TraversalType TraversalType = null;
switch (selectedAlgorithm)
{
case "BreadthFirst":
TraversalType = new BreadthFirst(_Map);
break;
case "DepthFirst":
TraversalType = new DepthFirst(_Map);
break;
case "DeadEndFill":
TraversalType = new DeadEndFill(_Map);
break;
case "FibonacciHeap":
break;
case "LeftTurn":
break;
default:
break;
}
return(TraversalType.Solve());
}
public void TraversePreorder(VisitNodeFunct2 visitNode, TraversalType type, bool delayVisit = false)
{
var visited = new Hashtable();
bool traverse = true;
Traverse((TNode c, TraversalListIDS <TNode> k) =>
{
if (type == TraversalType.DepthFirst || !visited.ContainsKey(c))
{
if (delayVisit)
{
Delay();
}
traverse = visitNode(c, k);
if (type == TraversalType.BreadthFirst)
{
visited.Add(c, (c.Level) * (c.ChildIndex + 1));
}
foreach (TNode child in c.Children)
{
k.Add(child);
}
}
return(traverse);
}, type);
}
public void CreateTest2(TraversalType ttype, int?[] data)
{
/* 1
* / \
* 2 2
* / \
* 3 3
* / \
* 4 4 */
var tree = TreeNode.Create(data, ttype);
Assert.Equal(1, tree.val);
Assert.Equal(2, tree.left.val);
Assert.Equal(3, tree.left.left.val);
Assert.Equal(4, tree.left.left.left.val);
Assert.Null(tree.left.left.left.left);
Assert.Null(tree.left.left.left.right);
Assert.Equal(4, tree.left.left.right.val);
Assert.Null(tree.left.left.right.left);
Assert.Null(tree.left.left.right.right);
Assert.Equal(3, tree.left.right.val);
Assert.Null(tree.left.right.right);
Assert.Null(tree.left.right.left);
Assert.Equal(2, tree.right.val);
Assert.Null(tree.right.left);
Assert.Null(tree.right.right);
}
public Traversal(TraversalType type, Tile tileFrom, Tile tileTo, int cost = 1)
{
Type = type;
TileFrom = tileFrom;
TileTo = tileTo;
Cost = cost;
}
protected IEnumerable <IDomObject> GetTraversalTargetElements(TraversalType traversalType, IEnumerable <IDomObject> list)
{
switch (traversalType)
{
case TraversalType.Filter:
return(list);
case TraversalType.Child:
return(GetChildElements(list));
case TraversalType.Adjacent:
return(GetAdjacentElements(list));
case TraversalType.Sibling:
return(GetSiblings(list));
case TraversalType.Descendent:
throw new InvalidOperationException("TraversalType.Descendant should not be found at this point.");
case TraversalType.All:
throw new InvalidOperationException("TraversalType.All should not be found at this point.");
default:
throw new NotImplementedException("Unimplemented traversal type.");
}
}
public GraphTraversalBuilder(TraversalType traversalType, bool recordTraversal)
{
Result = traversalType switch
{
TraversalType.BreadthFirstSearch => new BreadthFirstTraversal <TKey, TValue>(recordTraversal),
_ => throw new NotImplementedException()
};
}
public void Traverse(TraversalType traversalType, TrieVisitor visitor)
{
if (traversalType == TraversalType.InOrder)
{
throw new NotImplementedException("InOrder traversal not implemented yet.");
}
InternalTraverse(rootNode, traversalType, visitor);
}
public static async Task<IEnumerable<Node>> FindAsync(this GraphStorage storage,
Node rootNode,
Func<JObject, bool> searchPredicate,
TraversalType algorithmType,
CancellationToken cancelToken,
int? take = null)
{
using (var tx = storage.NewTransaction(TransactionFlags.Read))
return await storage.FindAsync(tx, rootNode, searchPredicate, algorithmType, cancelToken, take);
}
public static IEnumerable <int> AsEnumerableNoNull(this TreeNode tn, TraversalType ttype = TraversalType.LevelOrder)
{
foreach (var node in tn.AsEnumerable(ttype))
{
if (node != null)
{
yield return(node.Value);
}
}
}
public void Traverse(VisitNodeFunct2 visitNode, TraversalType type)
{
var ids = new TraversalListIDS <TNode>(type);
ids.Add(Root);
while (ids.Count > 0 && visitNode(ids.Take(), ids) == true)
{
;
}
}
/// <summary>
/// Finishes any open selector and clears the current selector
/// </summary>
protected void FinishSelector()
{
if (Current.IsComplete)
{
var cur = Current.Clone();
Selectors.Add(cur);
}
Current.Clear();
NextTraversalType = TraversalType.Filter;
NextCombinatorType = CombinatorType.Chained;
}
/// <summary>
/// Sets the traversal type for all CombinatorType.Root child selectors. This is useful for
/// subselectors; you may not want them to default to a filter.
/// </summary>
///
/// <param name="type">
/// The type.
/// </param>
public Selector SetTraversalType(TraversalType type)
{
foreach (var sel in Clauses)
{
if (sel.CombinatorType == CombinatorType.Root)
{
sel.TraversalType = type;
}
}
return(this);
}
/// <summary>
/// Close the currently active selector. If it's partial (e.g. a descendant/child marker) then merge its into into the
/// new selector created.
/// </summary>
/// <param name="selectorType"></param>
/// <param name="combinatorType"></param>
/// <param name="traversalType"></param>
protected void StartNewSelector(SelectorType selectorType,
CombinatorType combinatorType,
TraversalType traversalType)
{
// if a selector was not finished, do not overwrite the existing combinator & traversal types,
// as they could have been changed by a descendant or child selector.
if (TryFinishSelector())
{
Current.CombinatorType = combinatorType;
Current.TraversalType = traversalType;
}
Current.SelectorType = selectorType;
}
public TraversalListIDS(TraversalType type)
{
Type = type;
if (Type == TraversalType.DepthFirst)
{
K = new Stack <T>();
}
else if (Type == TraversalType.BreadthFirst)
{
Q = new Queue <T>();
}
}
public BaseTileObject(string objectName, string modelName, Vector3 modelOffset, bool hasHitBox, bool isCenter, CoverType solidity, TraversalType traversalKind)
{
ObjectName = objectName;
ModelName = modelName;
ModelOffset = modelOffset;
HasHitBox = hasHitBox;
this.isCenter = isCenter;
Solidity = solidity;
TraversalKind = traversalKind;
if (this.isCenter)
{
Position = Positioning.Center;
}
}
public void ReflectionTest(TraversalType ttype)
{
var f1 = TreeNodeHelper.GetFunction("Create", ttype);
Func <IEnumerable <int?>, TreeNode> f2 = ttype switch
{
TraversalType.PreOrder => TreeNodeHelper.CreateByPreOrder,
TraversalType.InOrder => TreeNodeHelper.CreateByInOrder,
TraversalType.PostOrder => TreeNodeHelper.CreateByPostOrder,
TraversalType.LevelOrder => TreeNodeHelper.CreateByLevelOrder,
_ => throw new NotImplementedException()
};
Assert.Equal(f2.Method, f1);
}
public static async Task<IEnumerable<Node>> FindAsync(this GraphStorage storage,
Transaction tx,
Node rootNode,
Func<JObject, bool> searchPredicate,
TraversalType algorithmType,
CancellationToken cancelToken,
int? take = null)
{
var searchVisitor = new SearchVisitor(searchPredicate, take ?? 0);
var traversalAlgorithm = new TraversalAlgorithm(tx, storage, rootNode, algorithmType, cancelToken)
{
Visitor = searchVisitor
};
await traversalAlgorithm.TraverseAsync();
return searchVisitor.Results;
}
/// <summary>
/// Map a list to its children or descendants, if needed.
/// </summary>
/// <param name="traversalType"></param>
/// <param name="list"></param>
/// <returns></returns>
protected IEnumerable <IDomObject> GetAllChildOrDescendants(TraversalType traversalType, IEnumerable <IDomObject> list)
{
switch (traversalType)
{
case TraversalType.All:
return(GetAllElements(list));
case TraversalType.Child:
return(GetChildElements(list));
case TraversalType.Descendent:
return(GetDescendantElements(list));
default:
return(list);
}
}
public void Traverse(Action <Node <T> > process, TraversalType travType)
{
if (Root == null)
{
return;
}
switch (travType)
{
case TraversalType.PreOrder: TraverseHelperPreOrder(process, Root); break;
case TraversalType.InOrder: TraverseHelperInOrder(process, Root); break;
case TraversalType.PostOrder: TraverseHelperPostOrder(process, Root); break;
case TraversalType.OutOrder: TraverseHelperOutOrder(process, Root); break;
}
}
public List <char> TraverseTree(TreeNode <char> tree, TraversalType traversalType)
{
var list = new List <char>();
switch (traversalType)
{
case TraversalType.PreOrderRecursive:
PreOrderTraverseNode(tree, list);
break;
case TraversalType.PreOrderIteratively:
PreOrderIterative(tree, list);
break;
case TraversalType.InOrderRecursive:
InOrderTraverseNode(tree.Left, list);
ProcessNode(tree, list);
InOrderTraverseNode(tree.Right, list);
break;
case TraversalType.InOrderIterative:
InOrderIterative(tree, list);
break;
case TraversalType.PostOrderRecursive:
PostOrderTraverseNode(tree.Left, list);
PostOrderTraverseNode(tree.Right, list);
ProcessNode(tree, list);
break;
case TraversalType.PostOrderIterative:
PostOrderIterative(tree, list);
break;
case TraversalType.BreadthFirst:
BreadthFirst(tree, list);
break;
default:
throw new Exception("Traversal type not recognised");
}
return(list);
}
/// <summary>
/// Map a list to its siblings or adjacent elements if needed. Ignore other traversal types.
/// </summary>
///
/// <param name="traversalType">
/// The traversal type
/// </param>
/// <param name="list">
/// The source list
/// </param>
///
/// <returns>
/// Sequence of adjacent or sibling elements.
/// </returns>
protected IEnumerable <IDomObject> GetAdjacentOrSiblings(TraversalType traversalType, IEnumerable <IDomObject> list)
{
IEnumerable <IDomObject> sourceList;
switch (traversalType)
{
case TraversalType.Adjacent:
sourceList = GetAdjacentElements(list);
break;
case TraversalType.Sibling:
sourceList = GetSiblings(list);
break;
default:
sourceList = list;
break;
}
return(sourceList);
}
private void InternalTraverse(Node node, TraversalType traversalType, TrieVisitor visitor)
{
if (traversalType == TraversalType.PreOrder && node.IsLeaf)
{
visitor.Visit(node);
}
char[] sortedChildrenKeys = node.Children.Keys.ToArray();
Array.Sort(sortedChildrenKeys);
foreach (char c in sortedChildrenKeys)
{
Node childNode = node.Children[c];
InternalTraverse(childNode, traversalType, visitor);
}
if (traversalType == TraversalType.PostOrder && node.IsLeaf)
{
visitor.Visit(node);
}
}
public void Traverse(TraversalType traverse)
{
switch (traverse)
{
case TraversalType.PreOrder:
TraversePreorder(root);
break;
case TraversalType.InOrdered:
TraverseInorder(root);
break;
case TraversalType.PostOrder:
TraversePostorder(root);
break;
default:
Console.WriteLine("What a #@$@#@!");
break;
}
}
/// <summary>
/// Close the currently active selector. If it's partial (e.g. a descendant/child marker) then merge its into into the
/// new selector created.
/// </summary>
/// <param name="selectorType"></param>
/// <param name="combinatorType"></param>
/// <param name="traversalType"></param>
protected void StartNewSelector(SelectorType selectorType,
CombinatorType combinatorType,
TraversalType traversalType)
{
// if a selector was not finished, do not overwrite the existing combinator & traversal types,
// as they could have been changed by a descendant or child selector. The exception is when
// the new selector is an explicit "all" type; we always
// a new selector will not have been started if there was an explicit "*" creating an all. However, if there's
// anything other than a filter, we do actually want
if (Current.IsComplete &&
Current.SelectorType != SelectorType.All || traversalType != TraversalType.Filter)
{
FinishSelector();
Current.CombinatorType = combinatorType;
Current.TraversalType = traversalType;
}
Current.SelectorType = selectorType;
}
public bool CanFind(TVal i, TraversalType traversalType, List <TVal> visitationList)
{
switch (traversalType)
{
case TraversalType.INORDER:
return(Root?.InOrder(i, visitationList) ?? false);
break;
case TraversalType.PREORDER:
return(Root?.PreOrder(i, visitationList) ?? false);
break;
case TraversalType.POSTORDER:
return(Root?.PostOrder(i, visitationList) ?? false);
break;
}
return(false);
}
public void Print(TraversalType type)
{
switch (type)
{
case TraversalType.inOrder:
PrintInOrder(baseNode);
break;
case TraversalType.postOrder:
PrintPostOrder(baseNode);
break;
case TraversalType.preOrder:
PrintPreOrder(baseNode);
break;
default:
PrintInOrder(baseNode);
break;
}
Console.WriteLine("");
}
public void CreateTreeTest1(TraversalType ttype, int?[] data)
{
/* 3
* / \
* 9 20
* / \
* 15 7 */
var tree = TreeNode.Create(data, ttype);
// 按照先序断言
Assert.Equal(3, tree.val);
Assert.Equal(9, tree.left.val);
Assert.Null(tree.left.left);
Assert.Null(tree.left.right);
Assert.Equal(20, tree.right.val);
Assert.Equal(15, tree.right.left.val);
Assert.Null(tree.right.left.left);
Assert.Null(tree.right.left.right);
Assert.Equal(7, tree.right.right.val);
Assert.Null(tree.right.right.left);
Assert.Null(tree.right.right.right);
}
public void TreeTraversal(TraversalType tt = TraversalType.Preorder)
{
switch (tt)
{
case TraversalType.Preorder:
PreorderTraversal(0);
break;
case TraversalType.Inorder:
InorderTraversal(0);
break;
case TraversalType.Postorder:
PostorderTraversal(0);
break;
case TraversalType.Layer:
LayerTraversal();
break;
default:
break;
}
}
public Solution(TraversalType traversalType)
{
this.traversalType = traversalType;
results = new List <LinkedList <Node> >();
}
public void Traverse(VisitNodeFunct2 visitNode, TraversalType type)
{
var ids = new TraversalListIDS<TNode>(type);
ids.Add(Root);
while (ids.Count > 0 && visitNode(ids.Take(), ids) == true) ;
}
public static IEnumerable <ContentPageContentItem> ContentPages(this IPublishedContent content, TraversalType traversalType = TraversalType.Children)
{
return(content.GetEnumerable("ContentPage", traversalType).Select(x => new ContentPageContentItem(x)));
}
/// <summary>
/// Generates a random tree
/// </summary>
/// <param name="depth">desired depth of tree</param>
/// <returns>
/// A newly generated Tree of specified degree "maxBreadth"
/// </returns>
public static Tree Generate(TraversalType gen_mechanism,
int depth,
int max_breadth,
int num_first_children = -1,
int max_nodes = -1)
{
Tree t = new Tree { Root = new TNode { Level = 1 } };
Random rnd = new Random();
int breadth;
int i;
TNode child;
var k = new TraversalListIDS<TNode>(gen_mechanism);
var visited = new Hashtable();
bool finished = false;
TNode c;
k.Add(t.Root);
while (k.Count > 0 && finished == false)
{
// generate new level of arbirary children until desired depth is reached
c = k.Take();
// finished when reached desired number of nodes or reached desired depth
if (max_nodes > 0)
{
finished = t.Count >= max_nodes;
}
else
{
finished = c.Level == depth + 1;
}
if (!finished && (gen_mechanism == TraversalType.DepthFirst || !visited.ContainsKey(c)))
{
if (gen_mechanism == TraversalType.BreadthFirst)
visited.Add(c, 0);
if (c.Level == 1)
{
if (num_first_children == -1)
{
breadth = rnd.Next(1, max_breadth + 1);
}
else
{
breadth = num_first_children;
}
}
else
{
breadth = rnd.Next(1, max_breadth + 1);
//if(c.Level==4){
// breadth = 1000;
//}
//if (c.Level == depth)
//{
// breadth = 255;
//}
}
for (i = 0; i < breadth; i++)
{
child = new TNode();
child.Parent = c;
child.Level = c.Level + 1;
child.ChildIndex = i;
if (child.Level > t.MaxDepth) t.MaxDepth = child.Level;
t.Count++;
c.Children.Add(child);
k.Add(child);
}
}
}
return t;
}
public void TraversePreorder(VisitNodeFunct2 visitNode, TraversalType type, bool delayVisit = false)
{
var visited = new Hashtable();
bool traverse = true;
Traverse((TNode c, TraversalListIDS<TNode> k) =>
{
if (type == TraversalType.DepthFirst || !visited.ContainsKey(c))
{
if (delayVisit) Delay();
traverse = visitNode(c, k);
if (type == TraversalType.BreadthFirst)
visited.Add(c, (c.Level) * (c.ChildIndex + 1));
foreach (TNode child in c.Children)
{
k.Add(child);
}
}
return traverse;
}, type);
}
private void tbLayoutAlgor_Scroll(object sender, EventArgs e)
{
switch (tbLayoutAlgor.Value)
{
case 0:
layout_type = TraversalType.BreadthFirst;
break;
case 1:
layout_type = TraversalType.DepthFirst;
break;
}
}
/// <summary>
/// Generates a random tree
/// </summary>
/// <param name="depth">desired depth of tree</param>
/// <returns>
/// A newly generated Tree of specified degree "maxBreadth"
/// </returns>
public static Tree Generate(TraversalType type,
int depth, int maxBreadth, int numFirstChildren = -1, int maxNodes = -1)
{
Tree t;
TNode r;
TNode c;
Random rnd;
int breadth;
int d;
bool finished;
int i;
TNode child;
TraversalListIDS<TNode> ids=new TraversalListIDS<TNode>(type);
int count;
rnd=new Random();
r=new TNode();
t=new Tree(r);
finished=false;
r.Level=1;
count=0;
ids.Add(r);
while(ids.Count > 0 && finished == false)
{
c=ids.Get();
// generate new level of arbirary children until desired depth is reached
if(c.Level==1)
{
if(numFirstChildren<=0)
{
breadth=rnd.Next(maxBreadth)+1;
}
else
{
breadth=numFirstChildren;
}
}
else
{
breadth=rnd.Next(maxBreadth)+1;
}
for(i = 0; i < breadth; i++)
{
child=new TNode();
child.Parent=c;
child.Level=c.Level+1;
child.ChildIndex = i;
count++;
c.Children.Add(child);
ids.Add(child);
}
// finished when reached desired number of nodes or reached desired depth
if(maxNodes > 0)
{
finished=count>=maxNodes;
}
else
{
finished=c.Level==depth;
}
}
return t;
}
/// <summary>
/// precondition: Root position specified
/// </summary>
public void LayoutTopDown2D(PointF radius, double edge_length, TraversalType type, bool grow)
{
var k = new TraversalListIDS<List<TNode>>(type);
//Root.Point.X = 0;
Root.Point.Y = 0;
Root.angle = 0;
Root.leftBisector = TREE_MAX_HORIZ;
Root.rightBisector = 0;
Root.leftTangent = TREE_MAX_HORIZ;
Root.rightTangent = 0;
int j;
double i;
double right_limit;
double left_limit;
double slice_space; // angle space for each slice in sector
double level_arc = 2.0; // TWO_PI*.25
double level_ratio; // derived level ratio
double arc; // arc length for a level
/* LAYOUT LEVEL */
double remaning_angle;
double prev_angle;
double prev_gap;
TNode prev_sibling;
TNode first_child;
List<TNode> parents;
TNode parent;
List<TNode> work_item;
parents = new List<TNode>();
parents.Add(Root);
k.Add(parents);
while (k.Count > 0)
{
prev_angle = Root.angle;
prev_sibling = first_child = null;
parents = new List<TNode>();
work_item = k.Take();
for (j = 0; j < work_item.Count; j++)
{
parent = work_item[j];
right_limit = parent.RightLimit();
left_limit = parent.LeftLimit();
slice_space = (left_limit - right_limit) / parent.Children.Count;
if (grow) edge_length += 0.01;
i = 0.5;
foreach (TNode child in parent.Children)
{
child.angle = right_limit + (i * slice_space);
child.Point.X = Root.Point.X + (child.angle * 60);
child.Point.Y = Root.Point.Y + (child.Level * 60);
if (child.HasChildren) // Is it a parent node?
{
if (first_child == null) first_child = child;
prev_gap = child.angle - prev_angle;
child.prev_gap = prev_gap;
child.rightBisector = child.angle - (prev_gap / 2.0);
if (prev_sibling != null) prev_sibling.leftBisector = child.rightBisector;
// setup sector space for potential decendants that are positioned from current node
if (child.Level == MaxDepth) level_ratio = 1.0;
else level_ratio = child.Level / (child.Level + 1.0);
arc = level_arc * (level_ratio * 30.0);
child.leftTangent = child.angle + arc;
child.rightTangent = child.angle - arc;
prev_angle = child.prev_angle = child.angle;
prev_sibling = child;
parents.Add(child);
}
i++;
}
}
if (first_child != null)
{
// calculate the remaining angle to define the next level/sector
remaning_angle = TREE_MAX_HORIZ - prev_sibling.angle;
first_child.rightBisector = (first_child.angle - remaning_angle) / 2.0;
prev_sibling.leftBisector = first_child.rightBisector + TREE_MAX_ANGLE;
}
if (parents.Count > 0)
k.Add(parents);
}
}
/// <summary>
/// Close the currently active selector. If it's partial (e.g. a descendant/child marker) then merge its into into the
/// new selector created.
/// </summary>
/// <param name="selectorType"></param>
/// <param name="combinatorType"></param>
/// <param name="traversalType"></param>
protected void StartNewSelector(SelectorType selectorType,
CombinatorType combinatorType,
TraversalType traversalType)
{
// if a selector was not finished, do not overwrite the existing combinator & traversal types,
// as they could have been changed by a descendant or child selector.
if (TryFinishSelector())
{
Current.CombinatorType = combinatorType;
Current.TraversalType = traversalType;
}
Current.SelectorType = selectorType;
}
protected IEnumerable<IDomObject> GetTraversalTargetElements(TraversalType traversalType, IEnumerable<IDomObject> list)
{
switch (traversalType)
{
case TraversalType.Filter:
return list;
case TraversalType.Child:
return GetChildElements(list);
case TraversalType.Adjacent:
return GetAdjacentElements(list);
case TraversalType.Sibling:
return GetSiblings(list);
case TraversalType.Descendent:
throw new InvalidOperationException("TraversalType.Descendant should not be found at this point.");
case TraversalType.All:
throw new InvalidOperationException("TraversalType.All should not be found at this point.");
default:
throw new NotImplementedException("Unimplemented traversal type.");
}
}
/// <summary>
/// Close the currently active selector. If it's partial (e.g. a descendant/child marker) then merge its into into the
/// new selector created.
/// </summary>
/// <param name="selectorType"></param>
/// <param name="combinatorType"></param>
/// <param name="traversalType"></param>
protected void StartNewSelector(SelectorType selectorType,
CombinatorType combinatorType,
TraversalType traversalType)
{
// if a selector was not finished, do not overwrite the existing combinator & traversal types,
// as they could have been changed by a descendant or child selector. The exception is when
// the new selector is an explicit "all" type; we always
// a new selector will not have been started if there was an explicit "*" creating an all. However, if there's
// anything other than a filter, we do actually want
if (Current.IsComplete &&
Current.SelectorType != SelectorType.All || traversalType != TraversalType.Filter)
{
FinishSelector();
Current.CombinatorType = combinatorType;
Current.TraversalType = traversalType;
}
Current.SelectorType = selectorType;
}
/// <summary>
/// Map a list to its children or descendants, if needed.
/// </summary>
/// <param name="traversalType"></param>
/// <param name="list"></param>
/// <returns></returns>
protected IEnumerable<IDomObject> GetAllChildOrDescendants(TraversalType traversalType, IEnumerable<IDomObject> list)
{
switch (traversalType)
{
case TraversalType.All:
return GetAllElements(list);
case TraversalType.Child:
return GetChildElements(list);
case TraversalType.Descendent:
return GetDescendantElements(list);
default:
return list;
}
}
/// <summary>
/// Map a list to its siblings or adjacent elements if needed. Ignore other traversal types.
/// </summary>
/// <param name="traversalType"></param>
/// <param name="list"></param>
/// <returns></returns>
protected IEnumerable<IDomObject> GetAdjacentOrSiblings(TraversalType traversalType, IEnumerable<IDomObject> list)
{
IEnumerable<IDomObject> sourceList;
switch (traversalType)
{
case TraversalType.Adjacent:
sourceList = GetAdjacentElements(list);
break;
case TraversalType.Sibling:
sourceList = GetSiblings(list);
break;
default:
sourceList = list;
break;
}
return sourceList;
}
/// <summary>
/// Finishes any open selector and clears the current selector
/// </summary>
protected void FinishSelector()
{
if (Current.IsComplete)
{
var cur = Current.Clone();
Selectors.Add(cur);
}
Current.Clear();
NextTraversalType = TraversalType.Filter;
NextCombinatorType = CombinatorType.Chained;
}
/// <summary>
/// Parse the string, and return a sequence of Selector objects
/// </summary>
/// <param name="selector"></param>
/// <returns></returns>
public Selector Parse(string selector)
{
Selectors = new Selector();
string sel = (selector ?? String.Empty).Trim();
if (IsHtml(selector))
{
Current.Html = sel;
Current.SelectorType = SelectorType.HTML;
Selectors.Add(Current);
return Selectors;
}
scanner = Scanner.Create(sel);
while (!scanner.Finished)
{
switch (scanner.Current)
{
case '*':
StartNewSelector(SelectorType.All);
scanner.Next();
break;
case '<':
// not selecting - creating html
Current.Html = sel;
scanner.End();
break;
case ':':
scanner.Next();
string key = scanner.Get(MatchFunctions.PseudoSelector).ToLower();
switch (key)
{
case "input":
AddTagSelector("input");
AddTagSelector("textarea",true);
AddTagSelector("select",true);
AddTagSelector("button",true);
break;
case "text":
StartNewSelector(SelectorType.AttributeValue | SelectorType.Tag);
Current.Tag = "input";
Current.AttributeSelectorType = AttributeSelectorType.Equals;
Current.AttributeName = "type";
Current.AttributeValue = "text";
StartNewSelector(SelectorType.AttributeValue | SelectorType.Tag, CombinatorType.Grouped, Current.TraversalType);
Current.Tag = "input";
Current.AttributeSelectorType = AttributeSelectorType.NotExists;
Current.AttributeName = "type";
Current.SelectorType |= SelectorType.Tag;
Current.Tag = "input";
break;
case "checkbox":
case "radio":
case "button":
case "file":
case "image":
case "password":
AddInputSelector(key,"input");
break;
case "reset":
case "submit":
AddInputSelector(key);
break;
case "checked":
case "selected":
case "disabled":
StartNewSelector(SelectorType.AttributeValue);
Current.AttributeSelectorType = AttributeSelectorType.Exists;
Current.AttributeName = key;
break;
case "enabled":
StartNewSelector(SelectorType.AttributeValue);
Current.AttributeSelectorType = AttributeSelectorType.NotExists;
Current.AttributeName = "disabled";
break;
case "first-letter":
case "first-line":
case "before":
case "after":
throw new NotImplementedException("The CSS pseudoelement selectors are not implemented in CsQuery.");
case "target":
case "link":
case "hover":
case "active":
case "focus":
case "visited":
throw new NotImplementedException("Pseudoclasses that require a browser aren't implemented.");
default:
if (!AddPseudoSelector(key)) {
throw new ArgumentException("Unknown pseudo-class :\"" + key + "\". If this is a valid CSS or jQuery selector, please let us know.");
}
break;
}
break;
case '.':
StartNewSelector(SelectorType.Class);
scanner.Next();
Current.Class = scanner.Get(MatchFunctions.CssClassName);
break;
case '#':
scanner.Next();
if (!scanner.Finished)
{
StartNewSelector(SelectorType.ID);
Current.ID = scanner.Get(MatchFunctions.HtmlIDValue());
}
break;
case '[':
StartNewSelector(SelectorType.AttributeValue);
IStringScanner innerScanner = scanner.ExpectBoundedBy('[', true).ToNewScanner();
Current.AttributeName = innerScanner.Get(MatchFunctions.HTMLAttribute());
innerScanner.SkipWhitespace();
if (innerScanner.Finished)
{
Current.AttributeSelectorType = AttributeSelectorType.Exists;
}
else
{
string matchType = innerScanner.Get("=", "^=", "*=", "~=", "$=", "!=","|=");
// CSS allows [attr=] as a synonym for [attr]
if (innerScanner.Finished)
{
Current.AttributeSelectorType = AttributeSelectorType.Exists;
}
else
{
var rawValue = innerScanner.Expect(expectsOptionallyQuotedValue()).ToNewScanner();
Current.AttributeValue = rawValue.Finished ?
"" :
rawValue.Get(new EscapedString());
switch (matchType)
{
case "=":
Current.SelectorType |= SelectorType.AttributeValue;
Current.AttributeSelectorType = AttributeSelectorType.Equals;
break;
case "^=":
Current.SelectorType |= SelectorType.AttributeValue;
Current.AttributeSelectorType = AttributeSelectorType.StartsWith;
// attributevalue starts with "" matches nothing
if (Current.AttributeValue == "")
{
Current.AttributeValue = "" + (char)0;
}
break;
case "*=":
Current.SelectorType |= SelectorType.AttributeValue;
Current.AttributeSelectorType = AttributeSelectorType.Contains;
break;
case "~=":
Current.SelectorType |= SelectorType.AttributeValue;
Current.AttributeSelectorType = AttributeSelectorType.ContainsWord;
break;
case "$=":
Current.SelectorType |= SelectorType.AttributeValue;
Current.AttributeSelectorType = AttributeSelectorType.EndsWith;
break;
case "!=":
Current.AttributeSelectorType = AttributeSelectorType.NotEquals;
// must matched manually - missing also validates as notEquals
break;
case "|=":
Current.SelectorType |= SelectorType.AttributeValue;
Current.AttributeSelectorType = AttributeSelectorType.StartsWithOrHyphen;
break;
default:
throw new ArgumentException("Unknown attibute matching operator '" + matchType + "'");
}
}
}
break;
case ',':
FinishSelector();
NextCombinatorType = CombinatorType.Root;
NextTraversalType = TraversalType.All;
scanner.NextNonWhitespace();
break;
case '+':
StartNewSelector(TraversalType.Adjacent);
scanner.NextNonWhitespace();
break;
case '~':
StartNewSelector(TraversalType.Sibling);
scanner.NextNonWhitespace();
break;
case '>':
StartNewSelector(TraversalType.Child);
// This is a wierd thing because if you use the > selector against a set directly, the meaning is "filter"
// whereas if it is used in a combination selector the meaning is "filter for 1st child"
//Current.ChildDepth = (Current.CombinatorType == CombinatorType.Root ? 0 : 1);
Current.ChildDepth = 1;
scanner.NextNonWhitespace();
break;
case ' ':
// if a ">" or "," is later found, it will be overridden.
scanner.NextNonWhitespace();
NextTraversalType = TraversalType.Descendent;
break;
default:
string tag = "";
if (scanner.TryGet(MatchFunctions.HTMLTagSelectorName(), out tag))
{
AddTagSelector(tag);
}
else
{
if (scanner.Index == 0)
{
Current.Html = sel;
Current.SelectorType = SelectorType.HTML;
scanner.End();
}
else
{
throw new ArgumentException(scanner.LastError);
}
}
break;
}
}
// Close any open selectors
FinishSelector();
if (Selectors.Count == 0)
{
var empty = new SelectorClause
{
SelectorType = SelectorType.None,
TraversalType = TraversalType.Filter
};
Selectors.Add(empty);
}
return Selectors;
}
protected void StartNewSelector(TraversalType traversalType)
{
StartNewSelector(0, CombinatorType.Chained, traversalType);
}
/// <summary>
/// Start a new chained selector that does not yet have a type specified
/// </summary>
/// <param name="traversalType"></param>
protected void StartNewSelector(TraversalType traversalType)
{
StartNewSelector(0, NextCombinatorType, traversalType);
}
/// <summary>
/// Start a new selector that does not yet have a type specified
/// </summary>
/// <param name="combinatorType"></param>
/// <param name="traversalType"></param>
protected void StartNewSelector(CombinatorType combinatorType, TraversalType traversalType)
{
StartNewSelector(0, combinatorType, traversalType);
}
public TreeTest(TraversalType traversalType)
{
Tree<string> tree;
TreeNode<string> root;
TreeNode<string> node;
_FullTree = new Tree<string>();
tree = _FullTree;
tree.TraversalOrder = traversalType;
root = new TreeNode<string>();
root.Data = "A";
tree.Root = root;
node = root.AddLeft("B");
node.AddLeft("C");
node.AddRight("D");
node = root.AddRight("E");
node.AddLeft("F");
node.AddRight("G");
_LeftOnlyTree = new Tree<string>();
tree = _LeftOnlyTree;
tree.TraversalOrder = traversalType;
root = new TreeNode<string>();
root.Data = "A";
tree.Root = root;
node = root.AddLeft("B");
node.AddLeft("C");
_RightOnlyTree = new Tree<string>();
tree = _RightOnlyTree;
tree.TraversalOrder = traversalType;
root = new TreeNode<string>();
root.Data = "A";
tree.Root = root;
node = root.AddRight("B");
node.AddRight("C");
_MissingFinalRightTree = new Tree<string>();
tree = _MissingFinalRightTree;
tree.TraversalOrder = traversalType;
root = new TreeNode<string>();
root.Data = "A";
tree.Root = root;
node = root.AddLeft("B");
node.AddLeft("C");
node = root.AddRight("D");
node.AddLeft("E");
_MissingFinalLeftTree = new Tree<string>();
tree = _MissingFinalLeftTree;
tree.TraversalOrder = traversalType;
root = new TreeNode<string>();
root.Data = "A";
tree.Root = root;
node = root.AddLeft("B");
node.AddRight("C");
node = root.AddRight("D");
node.AddRight("E");
}
protected void Initialize()
{
SelectorType = 0;
AttributeSelectorType = AttributeSelectorType.Equals;
CombinatorType = CombinatorType.Root;
TraversalType = TraversalType.All;
PositionType = PositionType.All;
}
private void tbGen_Scroll(object sender, EventArgs e)
{
switch (tbGen.Value)
{
case 0:
gen_type = TraversalType.BreadthFirst;
break;
case 1:
gen_type = TraversalType.DepthFirst;
break;
}
}
public void TraversePreorder(VisitNodeFunct visitNode, TraversalType type)
{
TraversalListIDS<TNode> ids=new TraversalListIDS<TNode>(type);
TNode c;
int i;
Hashtable visited=new Hashtable();
root.Parent=null;
root.Level=0;
ids.Add(root);
foreach(TNode rootChild in root.Children)
ids.Add(rootChild);
while(ids.Count > 0)
{
c=ids.Get();
if(!visited.ContainsKey(c))
{
visitNode(c);
visited.Add(c,0);
i=0;
foreach(TNode child in c.Children)
{
child.Parent=c;
child.Level=c.Level+1;
child.ChildIndex=i;
ids.Add(child);
}
}
}
}
