public virtual void Visit(TreeNodeVisitor visitor)
{
foreach (TreeNode treeNode in this)
{
treeNode.Visit(visitor);
}
}
//Converts a JSON sparql solution binding row into a graph result
private LabelledTreeNode <object, Term> CreateResultGraph(Dictionary <string, Binding> solution, LabelledTreeNode <object, Term> queryModel)
{
TreeNodeVisitor <object, object> visitor = (object nodeData) => ResolveNode(nodeData, solution);
var result = queryModel.Copy().Traverse(visitor);
return(result);
}
private void Traverse_PostOrder(TreeNode <T> node, TreeNodeVisitor <T> visitor)
{
foreach (TreeNode <T> kid in node.children)
{
Traverse_PostOrder(kid, visitor);
}
visitor(node);
}
public void UpdateCachedPostOrderLists()
{
_cachedPostOrder.Clear();
var postOrderDelegate = new TreeNodeVisitor <T>(AddToPostOrderList);
this.Traverse(this, postOrderDelegate, SearchOrder.PostOrder);
foreach (var child in children)
{
child.UpdateCachedPostOrderLists();
}
}
/// <summary>
/// Creates an instance of the zone tree builder
/// </summary>
/// <param name="significantBlockType">Significant block type</param>
/// <param name="significantInlineType">Significant inline type</param>
/// <param name="significantLinebreakType">Significant linebreak type</param>
/// <param name="significantInvisibleType">Significant invisible type</param>
/// <param name="breakDownType">Break down type</param>
/// <param name="anameType">A name type</param>
/// <param name="hiddenType">Hidden type</param>
/// <returns>
/// the created instance
/// </returns>
public static ZoneTreeBuilder Create(string significantBlockType, string significantInlineType, string significantLinebreakType, string significantInvisibleType, string breakDownType, string anameType, string hiddenType)
{
var startNewZoneFilter = new TypeFilter(significantLinebreakType);
var breakDownFilter = new TypeFilter(breakDownType);
var significantBlockFilter = new TypeFilter(significantBlockType);
var significantInlineFilter = new TypeFilter(significantInlineType);
var significantInvisibleFilter = new TypeFilter(significantInvisibleType);
var postProcessingSteps = new TreeNodeVisitor[] { };
var builder = new ZoneTreeBuilder(startNewZoneFilter, breakDownFilter, significantBlockFilter, significantInlineFilter, significantInvisibleFilter, postProcessingSteps);
return(builder);
}
public ShowTreeNodeVisitor()
{
TreeView view = new TreeView();
view.Dock = DockStyle.Fill;
view.Font = UI.NORMAL.Font;
TreeNodeVisitor v = new TreeNodeVisitor();
v.Visit(ExampleMachine.Dublin());
view.Nodes.Add(v.TreeNode);
Controls.Add(view);
Text = "Show Tree Node View";
}
public void Traverse(TreeNode <T> node, TreeNodeVisitor <T> visitor, SearchOrder searchOrder)
{
//switch statement was messing up intellisense for some reason?
if (searchOrder == SearchOrder.PostOrder)
{
Traverse_PostOrder(node, visitor);
}
if (searchOrder == SearchOrder.PreOrder)
{
Traverse_PreOrder(node, visitor);
}
if (searchOrder == SearchOrder.BreadthFirst)
{
Traverse_BreadthFirst(node, visitor);
}
}
/// <summary>
/// Traverse the tree and perform operations recursively
/// </summary>
/// <returns>
/// A new tree node that is, at every node, the result of the visit.
/// The stopper decides whether the exploration of a branch should be passed
/// </returns>
public LabelledTreeNode <TY, TE> Traverse <TY>(TreeNodeVisitor <TN, TY> nodeVisitor, Func <LabelledTreeNode <TN, TE>, bool> stopCondition = null)
{
var node = new LabelledTreeNode <TY, TE>(nodeVisitor(Value));
if (stopCondition == null)
{
stopCondition = d => false;
}
foreach (var child in Children)
{
if (!stopCondition(child.TerminalNode))
{
node.AddChild(child.Edge, child.TerminalNode.Traverse(nodeVisitor, stopCondition));
}
}
return(node);
}
public void Accept(TreeNodeVisitor visitor)
{
_treeNode.Accept(visitor);
}
public virtual void Accept <TContext>(TreeNodeVisitor <TContext> visitor, TContext context)
{
visitor.VisitNode(this, context);
}
public virtual TResult Accept <TContext, TResult>(TreeNodeVisitor <TContext, TResult> visitor, TContext context)
{
return(visitor.VisitNode(this, context));
}
public TReturn Accept <TContext, TReturn>(TreeNodeVisitor <TContext, TReturn> visitor, TContext context)
{
return(visitor.VisitNode(this, context));
}
public virtual void Accept(TreeNodeVisitor visitor)
{
visitor.VisitNode(this);
}
public void Accept <TContext>(TreeNodeVisitor <TContext> visitor, TContext context) => visitor.VisitYamlFileNode(this, context);
public TReturn Accept <TContext, TReturn>(TreeNodeVisitor <TContext, TReturn> visitor, TContext context) => visitor.VisitYamlFileNode(this, context);
public abstract TResult Accept <TContext, TResult>(TreeNodeVisitor <TContext, TResult> visitor, TContext context);
public void Accept(TreeNodeVisitor visitor) => visitor.VisitYamlFileNode(this);
public virtual void Visit(TreeNodeVisitor treeNodeVisitor)
{
treeNodeVisitor.Accept(this);
Nodes.Visit(treeNodeVisitor);
}
public abstract void Accept(TreeNodeVisitor visitor);
public virtual TReturn Accept <TContext, TReturn>(TreeNodeVisitor <TContext, TReturn> visitor, TContext context) => visitor.VisitNode(this, context);
public abstract TReturn Accept <TContext, TReturn>(TreeNodeVisitor <TContext, TReturn> visitor, TContext context);
public abstract void Accept <TContext>(TreeNodeVisitor <TContext> visitor, TContext context);
private void Traverse_BreadthFirst(TreeNode <T> node, TreeNodeVisitor <T> visitor)
{
throw new NotImplementedException();
}
public void Accept <TContext> (TreeNodeVisitor <TContext> visitor, TContext context)
{
_treeNode.Accept(visitor, context);
}
public virtual void Visit(TreeNodeVisitor treeNodeVisitor)
{
treeNodeVisitor.Accept(this);
Nodes.Visit(treeNodeVisitor);
}
public TReturn Accept <TContext, TReturn> (TreeNodeVisitor <TContext, TReturn> visitor, TContext context)
{
return(_treeNode.Accept(visitor, context));
}
