Java SyntaxTreeNode.getChildren方法代码示例

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
private int getRows(final SyntaxTreeNode node, final List<List<SyntaxTreeNode>> rows,
                    final int minIndentation) {
    int maxChildLevel = 0;
    int i = minIndentation;
    for (final SyntaxTreeNode child : node.getChildren()) {
        maxChildLevel = Math.max(getRows(child, rows, i), maxChildLevel);
        i = i + getWidth(child);
    }

    int level;
    if (node.getChildren().size() > 0) {
        level = maxChildLevel + 1;
    } else {
        level = 0;
    }

    while (rows.size() < level + 1) {
        rows.add(new ArrayList<>());
    }
    while (rows.get(level).size() < minIndentation + 1) {
        rows.get(level).add(null);
    }

    rows.get(level).set(minIndentation, node);
    return level;
}
 

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
private static int getRows(SyntaxTreeNode node,
                           List<List<SyntaxTreeNode>> result, int minIndentation) {
    if (node.getDependenciesLabelledAtThisNode().size() > 0) {
        return getRows(node.getChild(0), result, minIndentation);
    }
    int maxChildLevel = 0;
    int i = minIndentation;
    for (final SyntaxTreeNode child : node.getChildren()) {
        maxChildLevel = Math.max(getRows(child, result, i), maxChildLevel);
        i = i + getWidth(child);
    }

    final int level = node.getChildren().isEmpty() ? 0 : maxChildLevel + 1;

    while (result.size() < level + 1) {
        result.add(new ArrayList<SyntaxTreeNode>());
    }
    while (result.get(level).size() < minIndentation + 1) {
        result.get(level).add(null);
    }

    result.get(level).set(minIndentation, node);
    return level;
}
 

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
private SyntaxTreeNode getArgumentConstituent(final SyntaxTreeNode node, final int head, final int excludeIndex) {
	final boolean exclude = excludeIndex >= node.getStartIndex() && excludeIndex < node.getEndIndex();

	if (!exclude && node.getDependencyStructure().getArbitraryHead() == head) {
		return node;
	}

	for (final SyntaxTreeNode child : node.getChildren()) {
		final SyntaxTreeNode result = getArgumentConstituent(child, head, excludeIndex);
		if (result != null) {
			return result;
		}
	}

	return null;
}
 

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
private boolean updateNode(final List<SyntaxTreeNodeLeaf> result, final SyntaxTreeNode node) {

		boolean change = false;

		if (node.getChildren().size() == 2 && isVPtoAdverb(node.getChild(1))

				) {

			if (node.getChild(1).getLeaves().get(0).getCategory().equals(Category.valueOf("(S[to]\\NP)/(S[b]\\NP)"))) {
				// He retired (to spend time with family)
				setCategory(result, node.getChild(1).getLeaves().get(0).getHeadIndex(),
						Category.valueOf("((S\\NP)\\(S\\NP))/(S[b]\\NP)"));
				change = true;

			}

		}

		for (final SyntaxTreeNode child : node.getChildren()) {
			change = change || updateNode(result, child);
		}
		return change;
	}
 

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
private int getHash(final SyntaxTreeNode parse) {
	Integer result = nodeToHash.get(parse);
	if (result == null) {
		result = 0;

		// Add in a hash for each dependency at this node.
		final List<UnlabelledDependency> resolvedUnlabelledDependencies = parse
				.getResolvedUnlabelledDependencies();
		if (resolvedUnlabelledDependencies != null) {
			for (final UnlabelledDependency dep : resolvedUnlabelledDependencies) {
				for (final int arg : dep.getArguments()) {
					if (dep.getHead() != arg) {
						result = result
								^ categoryToArgumentToHeadToModifierToHash.get(dep.getCategory(),
										dep.getArgNumber())[dep.getHead()][arg];
					}
				}

			}
		}

		for (final SyntaxTreeNode child : parse.getChildren()) {
			result = result ^ getHash(child);
		}
	}

	return result;
}
 

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
public static void extractDependencies(final SyntaxTreeNode parse, final Collection<UnlabelledDependency> deps) {

		if (parse.getChildren().size() == 2) {

			deps.addAll(parse.getResolvedUnlabelledDependencies());
		}
		for (final SyntaxTreeNode child : parse.getChildren()) {
			extractDependencies(child, deps);
		}
	}
 

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
int getWidth(final SyntaxTreeNode node) {
	if (node.getChildren().size() == 0) {
		return 1;
	} else {
		int result = 0;

		for (final SyntaxTreeNode child : node.getChildren()) {
			result = result + getWidth(child);
		}

		return result;
	}
}
 

import edu.uw.easysrl.syntax.grammar.SyntaxTreeNode; //导入方法依赖的package包/类
int getRows(final SyntaxTreeNode node, final List<List<SyntaxTreeNode>> result, final int minIndentation) {

			if (node.getDependenciesLabelledAtThisNode().size() > 0) {
				return getRows(node.getChild(0), result, minIndentation);
			}
			int maxChildLevel = 0;
			int i = minIndentation;
			for (final SyntaxTreeNode child : node.getChildren()) {
				maxChildLevel = Math.max(getRows(child, result, i), maxChildLevel);
				i = i + getWidth(child);
			}

			int level;
			if (node.getChildren().size() > 0) {
				level = maxChildLevel + 1;
			} else {
				level = 0;
			}

			while (result.size() < level + 1) {
				result.add(new ArrayList<SyntaxTreeNode>());
			}
			while (result.get(level).size() < minIndentation + 1) {
				result.get(level).add(null);
			}

			result.get(level).set(minIndentation, node);
			return level;
		}