public ExtendedInfo(Info info, AdditionalNodeInformation additionalNodeInformation) { super(info.getId(), info.getNodeInfo(), info.getEdgeInfo()); this.additionalNodeInformation = additionalNodeInformation; }
/** * @return A string id that, hopefully, uniquely identifies a certain subtree. This is useful, for example, for differentiating between assignments to variables, etc. * @note id is not enough, because ids are not guaranteed to be unique. */ public static <T extends Info,S extends AbstractNode<T,S>> String uniqueSubtreeId(S parseTree) { return parseTree==null? null: parseTree.getInfo().getId()+" "+toEnglishSentence(parseTree); }
public static <T extends Info, S extends AbstractNode<T,S>> Map<String,S> mapIdToNode(S tree) throws TeEngineMlException { Map<String,S> ret = new LinkedHashMap<String, S>(); for (S node : TreeIterator.iterableTree(tree)) { String id = node.getInfo().getId(); if (null==id) throw new TeEngineMlException("Null id"); ret.put(id,node); } return ret; }
/** * @return a simple string representing the given info (serial, word, lemma, POS, dependency). * Based on {@link eu.excitementproject.eop.common.representation.parse.tree.AbstractNodeUtils#stringOfNode} */ public static String toString(Info info) { StringBuffer sb = new StringBuffer(); sb.append("["); if (info == null){ sb.append("null"); } else{ NodeInfo nodeInfo = info.getNodeInfo(); if (nodeInfo == null){ sb.append(", "); } else{ sb.append(info.getId()).append(", "); // info.getId() may be different than nodeInfo.getSerial() in case of variable substitutions! sb.append(InfoGetFields.getWord(info)).append(", "); sb.append(InfoGetFields.getLemma(info)).append(", "); sb.append(InfoGetFields.getPartOfSpeech(info)).append(", "); sb.append(InfoGetFields.getNamedEntityAnnotation(info)).append(", "); } sb.append(InfoGetFields.getRelation(info)); } sb.append("]"); return sb.toString(); }
sb.append(node.getInfo().getId()); sb.append("-"); sb.append(InfoGetFields.getLemma(node.getInfo()));
public Info newInfoRTT(Info nodeInfo, Info edgeInfo, Info additionalInformation) { return new DefaultInfo(nodeInfo.getId(), nodeInfo.getNodeInfo(), edgeInfo.getEdgeInfo()); }
public ExtendedInfo convertFromIR(Info info) { return new ExtendedInfo(info.getId(),info.getNodeInfo(),info.getEdgeInfo(),ExtendedNodeConstructor.EMPTY_ADDITIONAL_NODE_INFORMATION); }
public Info newInfoRT(Info nodeInfo, Info edgeInfo) { return new DefaultInfo(nodeInfo.getId(), nodeInfo.getNodeInfo(), edgeInfo.getEdgeInfo()); }
public Info newInfoFromTreeNodeAndRhsNodeAndRhsEdge(Info nodeInfo, Info ruleRhsNodeInfo, Info ruleRhsEdgeInfo) { return new DefaultInfo(nodeInfo.getId(), InfoServicesUtils.combineNodeInfo(nodeInfo, ruleRhsNodeInfo), ruleRhsEdgeInfo.getEdgeInfo()); }
public static boolean isArtificialRoot(AbstractNode<? extends Info, ?> node) { boolean ret = false; try { if (node.getInfo().getId().equals(AbstractBasicParser.ROOT_NODE_ID)) if (node.getInfo().getNodeInfo().getWordLemma()==null) ret = true; } catch(NullPointerException e) {} return ret; }
public ExtendedInfo newInfoRT(Info nodeInfo, ExtendedInfo edgeInfo) { return new ExtendedInfo(nodeInfo.getId(), nodeInfo.getNodeInfo(), edgeInfo.getEdgeInfo(), ExtendedNodeConstructor.EMPTY_ADDITIONAL_NODE_INFORMATION); }
public Info newInfoFromTreeNodeRhsNodeAndEdge(Info treeInfo, Info rhsInfo, Info edgeInfo) { return new DefaultInfo(treeInfo.getId(), InfoServicesUtils.combineNodeInfo(treeInfo, rhsInfo), edgeInfo.getEdgeInfo()); }
public ExtendedInfo convertFromIRT(Info info, ExtendedInfo additionalInformation) { return new ExtendedInfo(info.getId(),info.getNodeInfo(),info.getEdgeInfo(),ExtendedInfoGetFields.getAdditionalNodeInformation(additionalInformation)); }
public ExtendedInfo newInfoRTT(Info nodeInfo, ExtendedInfo edgeInfo, ExtendedInfo additionalInformation) { return new ExtendedInfo(nodeInfo.getId(), nodeInfo.getNodeInfo(), edgeInfo.getEdgeInfo(), ExtendedInfoGetFields.getAdditionalNodeInformation(additionalInformation)); }
/** * skip the artificial "ROOT" node * @param tree * @return * @throws AnnotatorException */ public static <N extends AbstractNode<? extends Info, N>> N skipRoot(N tree) throws AnnotatorException { if (tree == null) throw new AnnotatorException("got null tree"); N nodeToAnnotate; if (tree.getInfo().getId().equals(AbstractMiniparParser.ROOT_NODE_ID)) // skip the artificial "ROOT" node if (tree.hasChildren()) nodeToAnnotate = tree.getChildren().get(0); else throw new AnnotatorException("got a sentence that is an empty root: " + tree); else nodeToAnnotate = tree; return nodeToAnnotate; }
/** * for tracing. */ private static String outNode(BasicNode node) { String result = String.format("id=%s:ser=%d:%s:%s", node.getInfo().getId(), node.getInfo().getNodeInfo().getSerial(), node.getInfo().getNodeInfo().getWord(), node.getInfo().getEdgeInfo().getDependencyRelation()!=null?node.getInfo().getEdgeInfo().getDependencyRelation().getStringRepresentation():"null"); if (node.getAntecedent() != null) { result += String.format("(^%s)", outNode(node.getAntecedent())); } return result; }
public void makeOperation() { NodeInfo nodeInfo = null; try{nodeInfo = node.getInfo().getNodeInfo();}catch(Exception e){} String word = null; String lemma = null; int serial = 0; NamedEntity namedEntity = null; SyntacticInfo syntacticInfo = null; if (nodeInfo != null) { word = nodeInfo.getWord(); lemma = nodeInfo.getWordLemma(); serial = nodeInfo.getSerial(); syntacticInfo = nodeInfo.getSyntacticInfo(); } namedEntity = neWord.getNamedEntity(); Info oldInfo = node.getInfo(); node.setInfo(new DefaultInfo(oldInfo.getId(),new DefaultNodeInfo(word,lemma,serial,namedEntity,syntacticInfo),oldInfo.getEdgeInfo())); }
if (treeNodeInBasicNodeTree.getInfo()!=null) idOfTextTreeNode = treeNodeInBasicNodeTree.getInfo().getId(); if (null==idOfTextTreeNode) {idOfTextTreeNode="id_is_null";}
private static void addNeToAntecedents(BasicConstructionNode mutableParseTree) { for (BasicConstructionNode mutableNode : TreeIterator.iterableTree(mutableParseTree)) { if (mutableNode.getAntecedent()!=null) { BasicConstructionNode antecedent = AbstractNodeUtils.getDeepAntecedentOf(mutableNode); if (antecedent.getInfo().getNodeInfo().getNamedEntityAnnotation()!=null) { NamedEntity ne = antecedent.getInfo().getNodeInfo().getNamedEntityAnnotation(); Info newInfo = new DefaultInfo(mutableNode.getInfo().getId(), new DefaultNodeInfo(mutableNode.getInfo().getNodeInfo().getWord(), mutableNode.getInfo().getNodeInfo().getWordLemma(), mutableNode.getInfo().getNodeInfo().getSerial(), ne, mutableNode.getInfo().getNodeInfo().getSyntacticInfo()), mutableNode.getInfo().getEdgeInfo()); mutableNode.setInfo(newInfo); } } } }
@Override public Info supplementRightInfoWithLeftInfo(Info leftInfo, Info rightInfo) throws EntailmentCompilationException { if (leftInfo == null) throw new EntailmentCompilationException("got null left info"); if (rightInfo == null) throw new EntailmentCompilationException("got null right info"); Info alphaAnnotatedInfo = rightInfo; Info betaAnnotatedInfo = leftInfo; // choose args: alphaObj != null ? alphaObj : betaObj String lemma = (String) RuleBuildingUtils.chooseAlphaBeta(alphaAnnotatedInfo.getNodeInfo().getWordLemma(), betaAnnotatedInfo.getNodeInfo().getWordLemma()); EdgeInfo newEdgeAnnotatedInfo = new DefaultEdgeInfo( (DependencyRelation) RuleBuildingUtils.chooseAlphaBeta(alphaAnnotatedInfo.getEdgeInfo().getDependencyRelation(), betaAnnotatedInfo.getEdgeInfo().getDependencyRelation())); SyntacticInfo syntacticInfo = (SyntacticInfo) RuleBuildingUtils.chooseAlphaBeta(alphaAnnotatedInfo.getNodeInfo().getSyntacticInfo(), betaAnnotatedInfo.getNodeInfo().getSyntacticInfo()); // decide if to construct a NodeInfo or a VariableNodeAnnotatedInfo by the type of the betaNode? NodeInfo newAnnotatedNodeInfo; if (betaAnnotatedInfo.getNodeInfo().isVariable()) // copied variable nodes get the word and lemma of their lhs originals newAnnotatedNodeInfo = DefaultNodeInfo.newVariableDefaultNodeInfo (betaAnnotatedInfo.getNodeInfo().getVariableId(), null, -1, null, syntacticInfo); else { String word = (String) RuleBuildingUtils.chooseAlphaBeta(alphaAnnotatedInfo.getNodeInfo().getWord(), betaAnnotatedInfo.getNodeInfo().getWord()); newAnnotatedNodeInfo = new DefaultNodeInfo(word, lemma, -1, null, syntacticInfo); } Info newAnnotatedInfo = new DefaultInfo(betaAnnotatedInfo.getId(), newAnnotatedNodeInfo, newEdgeAnnotatedInfo); return newAnnotatedInfo; }