@Override public ImmutableSet<K> keySet() { ImmutableSet<K> ret = null; if (this.bidirectionalMap!=null) { ret = this.bidirectionalMap.leftSet(); } else { ret = this.valueSetMap.keySet(); } return ret; }
private String debug_print_mapLhsToTree() { StringBuilder sb = new StringBuilder(); for (RN ruleNode : mapLhsToTree.leftSet()) { String ruleLemma = "null"; if (ruleNode!=null) {ruleLemma = InfoGetFields.getLemma(ruleNode.getInfo());} TN treeNode = mapLhsToTree.leftGet(ruleNode); String treeLemma = "null"; if (treeNode!=null) {treeLemma = InfoGetFields.getLemma(treeNode.getInfo());} sb.append(ruleLemma).append(" --> ").append(treeLemma).append("\n"); } return sb.toString(); }
protected void flipToValueSetMap() { this.valueSetMap = new SimpleValueSetMap<K, V>(); for (K key : this.bidirectionalMap.leftSet()) { V value = this.bidirectionalMap.leftGet(key); this.valueSetMap.put(key, value); } this.bidirectionalMap = null; }
/** * Adds all (L,R) keys-values from <code>mapToAdd</code> to <code>map</code> * @param <L> * @param <R> * @param map * @param mapToAdd */ public static <L,R> void BidiMapAddAll(BidirectionalMap<L, R> map, BidirectionalMap<L, R> mapToAdd) { for (L l : mapToAdd.leftSet()) { if (!map.leftContains(l)) { map.put(l, mapToAdd.leftGet(l)); } } }
logger.info("done. "+this.mapTemplateToId.leftSet().size()+" templates were loaded.");
private void updateAntecedents() { for (ExtendedNode originalNode : mapOrigToGenerated.leftSet()) { if (originalNode.getAntecedent()!=null) { mapOrigToGenerated.leftGet(originalNode).setAntecedent(mapOrigToGenerated.leftGet(originalNode.getAntecedent())); } } }
public static <L, R, M> BidirectionalMap<L, R> concatenateBidiMaps(BidirectionalMap<L, M> map1,BidirectionalMap<M, R> map2) throws TeEngineMlException { boolean failed = false; BidirectionalMap<L, R> ret = new SimpleBidirectionalMap<L, R>(); for (L l : map1.leftSet()) { M m = map1.leftGet(l); if (!map2.leftContains(m)) failed=true; ret.put(l, map2.leftGet(m) ); } if (failed) throw new TeEngineMlException("Concatenation failed."); else return ret; } }
public void generate() { TreeCopier<I, S, I, S> copier = new TreeCopier<I, S, I, S>( originalTree, new TreeCopier.InfoConverter<S, I>() { @Override public I convert(S os) { return os.getInfo(); } }, nodeConstructor ); copier.copy(); generatedTree = copier.getGeneratedTree(); generatedTree.addChild(treeToPatch); BidirectionalMap<S, S> copierMap = copier.getNodesMap(); mapOriginalToGenerated = new SimpleValueSetMap<>(); for (S node : copierMap.leftSet()) { mapOriginalToGenerated.put(node, copierMap.leftGet(node)); } }
for (BasicNode node : map.leftSet())
for (S leftNode : rule.getMapNodes().leftSet())
for (BasicNode lhsNode : mapLhsToTreeInRuleMatch.leftSet())
@Override protected void generateTheTree() throws OperationException { affectedNodes = new LinkedHashSet<ExtendedNode>(); //BidirectionalMap<AbstractNode<Info,?>, EnglishNode> copyMap = AbstractNodeUtils.copyTreeReturnMap(textTree.getTree(), new EnglishNodeConstructor()); BidirectionalMap<ExtendedNode, ExtendedNode> copyMap = AbstractNodeUtils.strictTypeCopyTree(textTree.getTree(), new ExtendedNodeConstructor()); ExtendedNode duplicatedNode = new ExtendedNode(new ExtendedInfo(new DefaultInfo(nodeToMove.getInfo().getId(), nodeToMove.getInfo().getNodeInfo(), this.newEdgeInfo), nodeToMove.getInfo().getAdditionalNodeInformation()) ); ExtendedNode parentInGeneratedTree = copyMap.leftGet(newParent); parentInGeneratedTree.addChild(duplicatedNode); if (nodeToMove.getAntecedent()!=null) { ExtendedNode antecedentInOriginal = nodeToMove.getAntecedent(); ExtendedNode antecedentInGenerated = copyMap.leftGet(antecedentInOriginal); duplicatedNode.setAntecedent(antecedentInGenerated); } affectedNodes.add(duplicatedNode); this.generatedTree = copyMap.leftGet(textTree.getTree()); this.mapOriginalToGenerated = new SimpleValueSetMap<ExtendedNode, ExtendedNode>(); for (ExtendedNode originalNode : copyMap.leftSet()) { mapOriginalToGenerated.put(originalNode,copyMap.leftGet(originalNode)); } mapOriginalToGenerated.put(nodeToMove,duplicatedNode); }
log("Mapping:", debugPrint); BidirectionalMap<N, N> mapNodes = rule.getMapNodes(); for (N lhsNode : mapNodes.leftSet())
for (ExtendedNode originalNode : mapIsAConstructorOriginalToGenerated.leftSet())
for (ExtendedNode originalNode : mapOfRhsInstantiation.leftSet())