static boolean prefixMatches(Tree target, Tree pattern) {
if (pattern.isEmpty()) return true;
if (target.isEmpty() || target.value() != pattern.value()) return false;
return prefixMatches(target.left(), pattern.left())
&& prefixMatches(target.right(), pattern.right());
}
public static <A> void printTree(Tree<A> tree, PrintStream ps)
{
ps.printf("(%s (", tree.value());
for (Tree<A> t : tree.children())
{
printTree(t, ps);
ps.print(",");
}
ps.print("))");
}
// TODO all this is very memory inefficient and will lead to stack overflows for very deep trees
public static ObjectNode toJsonTree(ObjectMapper objectMapper, Tree<? extends JsonNode> tree)
{
final ObjectNode node = objectMapper.createObjectNode();
node.put("_value", tree.value());
final ArrayNode children = objectMapper.createArrayNode();
for (Tree<? extends JsonNode> child : tree.children())
children.add(toJsonTree(objectMapper, child));
node.put("_children", children);
return node;
}
/**
* Map a function over a tree
*
* @param fn Function
* @param tree Tree of {@code A}'s
* @return Tree of {@code B}'s
*/
public static <A,B> Tree<B> map(final Function<A,B> fn, Tree<A> tree)
{
final B value = fn.apply(tree.value());
if (isLeaf(tree))
return new ImmutableTree<B>(value);
else
{
final Function<Tree<A>,Tree<B>> tmap = new Function<Tree<A>,Tree<B>>()
{
public Tree<B> apply(Tree<A> tree)
{
return map(fn, tree);
}
};
final Iterable<Tree<B>> tb = Iterables.transform(tree.children(), tmap);
return new ImmutableTree<B>(value, tb);
}
}
private static boolean includesEmptyNPSubj(Tree t) {
if (t == null) {
return false;
}
Tree[] kids = t.children();
if (kids == null) {
return false;
}
boolean foundNullSubj = false;
for (Tree kid : kids) {
Tree[] kidkids = kid.children();
if (NPSbjPattern.matcher(kid.value()).matches()) {
kid.setValue("NP");
if (kidkids != null && kidkids.length == 1 && kidkids[0].value().equals("-NONE-")) {
// only set flag, since there are 2 a couple of times (errors)
foundNullSubj = true;
}
}
}
return foundNullSubj;
}
/**
* Add -TMP when not present within an NP
*
* @param tree The tree to add temporal info to.
*/
private void addTMP9(final Tree tree) {
// do the head chain under it
Tree ht = headFinder.determineHead(tree);
// special fix for possessives! -- make noun before head
if (ht.value().equals("POS")) {
int j = tree.objectIndexOf(ht);
if (j > 0) {
ht = tree.getChild(j - 1);
}
}
// Note: this next bit changes the tree label, rather
// than creating a new tree node. Beware!
if (ht.isPreTerminal()
|| ht.value().startsWith("NP")
|| ht.value().startsWith("PP")
|| ht.value().startsWith("ADVP")) {
if (!TmpPattern.matcher(ht.value()).matches()) {
LabelFactory lf = ht.labelFactory();
// System.err.println("TMP: Changing " + ht.value() + " to " +
// ht.value() + "-TMP");
ht.setLabel(lf.newLabel(ht.value() + "-TMP"));
}
if (ht.value().startsWith("NP")
|| ht.value().startsWith("PP")
|| ht.value().startsWith("ADVP")) {
addTMP9(ht);
}
}
// do the NPs under it (which may or may not be the head chain
Tree[] kidlets = tree.children();
for (int k = 0; k < kidlets.length; k++) {
ht = kidlets[k];
LabelFactory lf;
if (tree.isPrePreTerminal() && !TmpPattern.matcher(ht.value()).matches()) {
// System.err.println("TMP: Changing " + ht.value() + " to " +
// ht.value() + "-TMP");
lf = ht.labelFactory();
// Note: this next bit changes the tree label, rather
// than creating a new tree node. Beware!
ht.setLabel(lf.newLabel(ht.value() + "-TMP"));
} else if (ht.value().startsWith("NP")) {
// don't add -TMP twice!
if (!TmpPattern.matcher(ht.value()).matches()) {
lf = ht.labelFactory();
// System.err.println("TMP: Changing " + ht.value() + " to " +
// ht.value() + "-TMP");
// Note: this next bit changes the tree label, rather
// than creating a new tree node. Beware!
ht.setLabel(lf.newLabel(ht.value() + "-TMP"));
}
addTMP9(ht);
}
}
}