public override Tree Evaluate(Tree tree, TregexMatcher tregex)
{
// find match and get its parent
Tree targetNode = this.childMatcher[0].Evaluate(tree, tregex);
Tree parent = targetNode.Parent(tree);
// substitute original node for foot of auxiliary tree. Foot node is ignored
AuxiliaryTree ft = this._enclosing.AdjunctionTree().Copy(this, tree.TreeFactory(), tree.Label().LabelFactory());
// log.info("ft=" + ft + "; ft.foot=" + ft.foot + "; ft.tree=" + ft.tree);
Tree parentOfFoot = ft.foot.Parent(ft.tree);
if (parentOfFoot == null)
{
AdjoinToFootNode.log.Info("Warning: adjoin to foot for depth-1 auxiliary tree has no effect.");
return(tree);
}
int i = parentOfFoot.ObjectIndexOf(ft.foot);
if (parent == null)
{
parentOfFoot.SetChild(i, targetNode);
return(ft.tree);
}
else
{
int j = parent.ObjectIndexOf(targetNode);
parent.SetChild(j, ft.tree);
parentOfFoot.SetChild(i, targetNode);
return(tree);
}
}
public AdjoinNode(string name, AuxiliaryTree t, TsurgeonPattern p)
: base(name, new TsurgeonPattern[] { p })
{
if (t == null || p == null)
{
throw new ArgumentNullException("AdjoinNode: illegal null argument, t=" + t + ", p=" + p);
}
adjunctionTree = t;
}
/// <summary>
/// Combines all nodes between start and end into one subtree, then
/// replaces those nodes with the new subtree in the corresponding
/// location under parent
/// </summary>
public override Tree Evaluate(Tree tree, TregexMatcher tregex)
{
Tree startChild = this.childMatcher[0].Evaluate(tree, tregex);
Tree endChild = (this.childMatcher.Length == 2) ? this.childMatcher[1].Evaluate(tree, tregex) : startChild;
Tree parent = startChild.Parent(tree);
// sanity check
if (parent != endChild.Parent(tree))
{
throw new TsurgeonRuntimeException("Parents did not match for trees when applied to " + this);
}
AuxiliaryTree treeCopy = this._enclosing.auxTree.Copy(this, tree.TreeFactory(), tree.Label().LabelFactory());
// Collect all the children of the parent of the node we care
// about. If the child is one of the nodes we care about, or
// between those two nodes, we add it to a list of inner children.
// When we reach the second endpoint, we turn that list of inner
// children into a new node using the newly created label. All
// other children are kept in an outer list, with the new node
// added at the appropriate location.
IList <Tree> children = Generics.NewArrayList();
IList <Tree> innerChildren = Generics.NewArrayList();
bool insideSpan = false;
foreach (Tree child in parent.Children())
{
if (child == startChild || child == endChild)
{
if (!insideSpan && startChild != endChild)
{
insideSpan = true;
innerChildren.Add(child);
}
else
{
insideSpan = false;
innerChildren.Add(child);
// All children have been collected; place these beneath the foot of the auxiliary tree
treeCopy.foot.SetChildren(innerChildren);
children.Add(treeCopy.tree);
}
}
else
{
if (insideSpan)
{
innerChildren.Add(child);
}
else
{
children.Add(child);
}
}
}
parent.SetChildren(children);
return(tree);
}
public override Tree Evaluate(Tree tree, TregexMatcher tregex)
{
// find match
Tree targetNode = this.childMatcher[0].Evaluate(tree, tregex);
// put children underneath target in foot of auxilary tree
AuxiliaryTree ft = this._enclosing.AdjunctionTree().Copy(this, tree.TreeFactory(), tree.Label().LabelFactory());
ft.foot.SetChildren(targetNode.GetChildrenAsList());
// put children of auxiliary tree under target. root of auxiliary tree is ignored. root of original is maintained.
targetNode.SetChildren(ft.tree.GetChildrenAsList());
return(tree);
}
public override Tree Evaluate(Tree tree, TregexMatcher tregex)
{
// find match and get its parent
Tree targetNode = this.childMatcher[0].Evaluate(tree, tregex);
Tree parent = targetNode.Parent(tree);
// put children underneath target in foot of auxilary tree
AuxiliaryTree ft = this._enclosing.adjunctionTree.Copy(this, tree.TreeFactory(), tree.Label().LabelFactory());
ft.foot.SetChildren(targetNode.GetChildrenAsList());
// replace match with root of auxiliary tree
if (parent == null)
{
return(ft.tree);
}
else
{
int i = parent.ObjectIndexOf(targetNode);
parent.SetChild(i, ft.tree);
return(tree);
}
}
public AdjoinToHeadNode(AuxiliaryTree t, TsurgeonPattern p)
: base("adjoinH", t, p)
{
}
public HoldTreeNode(AuxiliaryTree t)
: base("hold", TsurgeonPattern.EmptyTsurgeonPatternArray)
{
this.subTree = t;
}
public AdjoinToFootNode(AuxiliaryTree t, TsurgeonPattern p)
: base("adjoinF", t, p)
{
}
public InsertNode(AuxiliaryTree t, TreeLocation l)
: this(new HoldTreeNode(t), l)
{
// Copy occurs in HoldTreeNode's `evaluate` method
needsCopy = false;
}
public CreateSubtreeNode(TsurgeonPattern start, TsurgeonPattern end, AuxiliaryTree tree)
: base("combineSubtrees", (end == null) ? new TsurgeonPattern[] { start } : new TsurgeonPattern[] { start, end })
{
this.auxTree = tree;
FindFoot();
}
public CreateSubtreeNode(TsurgeonPattern start, AuxiliaryTree tree)
: this(start, null, tree)
{
}
public virtual void TestUnescape()
{
NUnit.Framework.Assert.AreEqual("asdf", AuxiliaryTree.Unescape("asdf"));
NUnit.Framework.Assert.AreEqual("asdf=", AuxiliaryTree.Unescape("asdf\\="));
NUnit.Framework.Assert.AreEqual("asdf\\=", AuxiliaryTree.Unescape("asdf\\\\="));
}
public AdjoinNode(AuxiliaryTree t, TsurgeonPattern p)
: this("adjoin", t, p)
{
}