protected OntologyTerm newInternalOntologyTerm(OntologyIndexSearcher searcher, String id, String name, Collection<String> synonyms) { return new LazyLoadedOntologyTerm(searcher, id, name, synonyms); }
@Override public Set<OntologyTerm> getAllParentsToRoot(boolean includeSynonyms) { return getAllParentsToRoot(this, includeSynonyms); }
public List<OntologyTerm> getChildren() { return getChildren(false); }
public List<OntologyTerm> getParents(boolean includeCyclic) { if (parents != null) { return parents; } this.parents = new ArrayList<OntologyTerm>(); try { final OntologyHits ontologyHits = searchQuery(FieldName.CHILDREN_ID, includeCyclic); parents.addAll(processParentsHits(ontologyHits, id)); } catch (IOException e) { throw new IllegalStateException("Problem getting parents for document: "+id, e); } return parents; }
public List<OntologyTerm> getChildren(boolean includeCyclic) { if (children != null) { return children; } this.children = new ArrayList<OntologyTerm>(); try { final OntologyHits ontologyHits = searchQuery(FieldName.PARENT_ID, includeCyclic); children.addAll(processChildrenHits(ontologyHits, id)); } catch (IOException e) { throw new IllegalStateException("Problem getting children for document: "+id, e); } return children; }
private List<OntologyTerm> processParentsHits(OntologyHits ontologyHits, String id) throws IOException { List<OntologyTerm> terms = new ArrayList<OntologyTerm>(); List<String> processedIds = new ArrayList<String>(); processedIds.add(id); for (int i=0; i<ontologyHits.length(); i++) { final OntologyDocument document = ontologyHits.doc(i); if (document.getParentId() != null && !processedIds.contains(document.getParentId())) { terms.add(newInternalOntologyTerm(searcher, document.getParentId(), document.getParentName(), document.getParentSynonyms())); processedIds.add(document.getParentId()); } } return terms; }
public List<OntologyTerm> getParents() { return getParents(false); }
private List<OntologyTerm> processChildrenHits(OntologyHits ontologyHits, String id) throws IOException { List<OntologyTerm> terms = new ArrayList<OntologyTerm>(); List<String> processedIds = new ArrayList<String>(); processedIds.add(id); for (int i=0; i<ontologyHits.length(); i++) { final OntologyDocument document = ontologyHits.doc(i); if (document.getChildId() != null && !processedIds.contains(document.getChildId())) { terms.add(newInternalOntologyTerm(searcher, document.getChildId(), document.getChildName(), document.getChildSynonyms())); processedIds.add(document.getParentId()); } } return terms; }
public Set<OntologyTerm> getAllParentsToRoot() { return getAllParentsToRoot(this, false); }
public Collection<OntologyTerm> getChildrenAtDepth(int depth) { return getChildren(this, 0, depth).get(depth); }
@Override public Set<OntologyTerm> getSynonyms() { if (synonyms != null) { return synonyms; } synonyms = new HashSet<OntologyTerm>(); if (parentSynonyms == null || parentSynonyms.isEmpty()) { return synonyms; } for (String synonym : parentSynonyms) { OntologyTerm ontologyTerm = new LazyLoadedOntologyTerm(searcher, id, synonym); synonyms.add(ontologyTerm); } return synonyms; }
protected Set<OntologyTerm> getAllParentsToRoot(OntologyTerm ontologyTerm, boolean includeSynonyms) { Set<OntologyTerm> parents = new HashSet<OntologyTerm>(); for (OntologyTerm parent : ontologyTerm.getParents()) { parents.add(parent); if (includeSynonyms) { Set<OntologyTerm> synonyms = parent.getSynonyms(); parents.addAll(synonyms); } parents.addAll(getAllParentsToRoot(parent, includeSynonyms)); } return parents; }
protected Multimap<Integer, OntologyTerm> getChildren(OntologyTerm term, int currentDepth, int maxDepth) { if (currentDepth > maxDepth) { return HashMultimap.create(); } Multimap<Integer,OntologyTerm> terms = HashMultimap.create(); terms.put(currentDepth, term); for (OntologyTerm child : term.getChildren()) { terms.putAll(getChildren(child, currentDepth+1, maxDepth)); } return terms; }