/** * Start at the given nesting level - read lines until you get to line with equal to or greater * than the current one. */ public static String[] getArtifactLines(Pointer startingIndex, String... lines) { List<String> lineList = new ArrayList<>(); int index = startingIndex.getIndex(); String topLine = lines[index]; lineList.add( topLine); // add the line which defines this object - all others, if they exist, are // children. int nestingLevel = parseNestingLevel(topLine); for (int i = index + 1; i < lines.length; i++) { String line = lines[i]; // we return if the nesting level of the line in question is the same as the "parent" level int childNestingLevel = parseNestingLevel(line); if (childNestingLevel == nestingLevel) { startingIndex.increment(lineList.size()); // return new array of startIndex to i return lineList.toArray(new String[lineList.size()]); } else { lineList.add(line); } } startingIndex.increment(lineList.size()); return lineList.toArray(new String[lineList.size()]); }
private void checkPointers() { if (null != dictionary && dictionary.getCheckAlienPointers() && !checkingPointers) { synchronized (this) { checkingPointers = true; if (null != dictionary && dictionary.isEditable()) { List<Pointer> toDelete = null; for (int i = 0; i < super.size(); i++) { Pointer pointer = super.get(i); if (dictionary != pointer.getSource().getDictionary() || null == pointer.getTarget() || dictionary != pointer.getTarget().getDictionary()) { if (null == toDelete) { toDelete = new ArrayList<Pointer>(); } toDelete.add(pointer); } } if (null != toDelete) { if (log.isWarnEnabled() && 0 < toDelete.size()) { log.warn(JWNL.resolveMessage("DICTIONARY_WARN_002", Synset.this.getOffset())); } for (Pointer pointer : toDelete) { remove(pointer); } } } checkingPointers = false; } } }
private static Set<Long> findAdverbAntonyms(Dictionary dic) throws SMatchException { log.info("Creating adverb antonyms array..."); try { Set<Long> keys = new HashSet<>(); int count = 0; Iterator<Synset> it = dic.getSynsetIterator(POS.ADVERB); while (it.hasNext()) { count++; if (0 == count % 1000) { log.debug("adverb antonyms: " + count); } Synset source = it.next(); long sourceOffset = source.getOffset(); List<Pointer> pointers = source.getPointers(PointerType.ANTONYM); for (Pointer ptr : pointers) { long targetOffset = ptr.getTargetOffset(); long key; if (targetOffset > sourceOffset) { key = (targetOffset << 32) + sourceOffset; } else { key = (sourceOffset << 32) + targetOffset; } keys.add(key); } } log.info("Adverbs antonyms: " + keys.size()); return keys; } catch (JWNLException e) { throw new SMatchException(e.getClass().getSimpleName() + ": " + e.getMessage(), e); } }
private static Set<Long> findNominalizations(Dictionary dic) throws SMatchException { log.info("Creating nominalizations array..."); try { Set<Long> keys = new HashSet<>(); int count = 0; Iterator<Synset> it = dic.getSynsetIterator(POS.VERB); while (it.hasNext()) { count++; if (0 == count % 1000) { log.debug("nominalizations: " + count); } Synset source = it.next(); List<Pointer> pointers = source.getPointers(PointerType.DERIVATION); for (Pointer pointer : pointers) { if (POS.NOUN.equals(pointer.getTargetPOS())) { long targetOffset = pointer.getTargetOffset(); long key = (source.getOffset() << 32) + targetOffset; keys.add(key); } } } log.info("Nominalizations: " + keys.size()); return keys; } catch (JWNLException e) { throw new SMatchException(e.getClass().getSimpleName() + ": " + e.getMessage(), e); } }
@Override public boolean retainAll(Collection<?> c) { if (null != dictionary && dictionary.isEditable()) { List<Pointer> copy = new ArrayList<Pointer>(this); boolean result = super.retainAll(c); for (Object object : c) { if (object instanceof Pointer) { Pointer pointer = (Pointer) object; if (!copy.contains(pointer)) { // delete symmetric pointer from the target if (null != pointer.getType().getSymmetricType() && dictionary.getManageSymmetricPointers()) { for (Pointer p : pointer.getTargetSynset().getPointers()) { if (offset == p.getTargetOffset() && pointer.getType().getSymmetricType().equals(p.getType())) { pointer.getTargetSynset().getPointers().remove(p); break; } } } } } } return result; } else { return super.retainAll(c); } }
private static void cartPr(Set<Long> keys, List<Pointer> t) throws JWNLException { for (int i = 0; i < t.size(); i++) { Pointer ps = t.get(i); long sourceOffset = ps.getTargetSynset().getOffset(); for (int j = i + 1; j < t.size(); j++) { Pointer pt = t.get(j); long targetOffset = pt.getTargetSynset().getOffset(); if (sourceOffset != targetOffset) { long key; if (targetOffset > sourceOffset) { key = (targetOffset << 32) + sourceOffset; } else { key = (sourceOffset << 32) + targetOffset; } keys.add(key); } } } }
@Override public boolean remove(Object o) { boolean result = super.remove(o); if (null != dictionary && dictionary.isEditable() && dictionary.getManageSymmetricPointers() && o instanceof Pointer) { Pointer pointer = (Pointer) o; // delete symmetric pointer from the target if (null != pointer.getType().getSymmetricType()) { if (null != pointer.getTargetSynset()) { for (Pointer p : pointer.getTargetSynset().getPointers()) { if (offset == p.getTargetOffset() && pointer.getType().getSymmetricType().equals(p.getType())) { pointer.getTargetSynset().getPointers().remove(p); break; } } } } } return result; }
@Override public Pointer remove(int index) { Pointer result = super.remove(index); if (null != dictionary && dictionary.isEditable() && dictionary.getManageSymmetricPointers()) { // delete symmetric pointer from the target Pointer pointer = get(index); if (null != pointer.getType().getSymmetricType()) { for (Pointer p : pointer.getTargetSynset().getPointers()) { if (offset == p.getTargetOffset() && pointer.getType().getSymmetricType().equals(p.getType())) { pointer.getTargetSynset().getPointers().remove(p); break; } } } } return result; }
@Override protected void removeRange(int fromIndex, int toIndex) { if (null != dictionary && dictionary.isEditable()) { List<Pointer> copy = new ArrayList<Pointer>(super.subList(fromIndex, toIndex)); super.removeRange(fromIndex, toIndex); for (Pointer pointer : copy) { // delete symmetric pointer from the target if (null != pointer.getType().getSymmetricType() && dictionary.getManageSymmetricPointers()) { for (Pointer p : pointer.getTargetSynset().getPointers()) { if (offset == p.getTargetOffset() && pointer.getType().getSymmetricType().equals(p.getType())) { pointer.getTargetSynset().getPointers().remove(p); break; } } } } } else { super.removeRange(fromIndex, toIndex); } }
@Override public void clear() { if (null != dictionary && dictionary.isEditable()) { List<Pointer> copy = new ArrayList<Pointer>(this); super.clear(); for (Pointer pointer : copy) { // delete symmetric pointer from the target if (null != pointer.getType().getSymmetricType() && dictionary.getManageSymmetricPointers()) { for (Pointer p : pointer.getTargetSynset().getPointers()) { if (offset == p.getTargetOffset() && pointer.getType().getSymmetricType().equals(p.getType())) { pointer.getTargetSynset().getPointers().remove(p); break; } } } } } else { super.clear(); } }
@Override public void add(int index, Pointer pointer) { if (null == pointer) { throw new IllegalArgumentException(JWNL.resolveMessage("DICTIONARY_EXCEPTION_043")); } super.add(index, pointer); if (null != dictionary && dictionary.isEditable() && dictionary.getManageSymmetricPointers()) { if (null != pointer.getType().getSymmetricType()) { Pointer symmetric = new Pointer( pointer.getType().getSymmetricType(), pointer.getTarget(), pointer.getSource()); if (!pointer.getTarget().getSynset().getPointers().contains(symmetric)) { pointer.getTarget().getSynset().getPointers().add(symmetric); } } } }