Extract an interface from AbstractOntologyService to make it easier to reuse

Author: arteymix

src/ubic/basecode/ontology/model/OntologyTerm.java

@@ -1,8 +1,8 @@
 /*
  * The basecode project
- * 
+ *
  * Copyright (c) 2007-2019 Columbia University
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -22,48 +22,53 @@
 
 /**
  * @author Paul
- * 
  */
 public interface OntologyTerm extends OntologyResource {
 
-    public Collection<String> getAlternativeIds();
+    Collection<String> getAlternativeIds();
 
-    public Collection<AnnotationProperty> getAnnotations();
+    Collection<AnnotationProperty> getAnnotations();
+
+    Collection<OntologyTerm> getChildren( boolean direct );
 
     /**
      * @param direct return only the immediate children; if false, return all of them down to the leaves.
+     * @param includePartOf include terms matched via
      * @return
      */
-    public Collection<OntologyTerm> getChildren( boolean direct );
+    Collection<OntologyTerm> getChildren( boolean direct, boolean includePartOf );
 
-    public String getComment();
+    String getComment();
 
-    public Collection<OntologyIndividual> getIndividuals();
+    Collection<OntologyIndividual> getIndividuals();
 
-    public Collection<OntologyIndividual> getIndividuals( boolean direct );
+    Collection<OntologyIndividual> getIndividuals( boolean direct );
 
-    public String getLocalName();
+    String getLocalName();
 
-    public Object getModel();
+    Object getModel();
 
     /**
      * Note that any restriction superclasses are not returned, unless they are has_proper_part
-     * 
+     *
      * @param direct
      * @return
      */
-    public Collection<OntologyTerm> getParents( boolean direct );
+    Collection<OntologyTerm> getParents( boolean direct );
 
-    public Collection<OntologyRestriction> getRestrictions();
+    Collection<OntologyTerm> getParents( boolean direct, boolean includePartOf );
 
-    public String getTerm();
+    Collection<OntologyRestriction> getRestrictions();
 
-    @Override
-    public String getUri();
+    String getTerm();
 
-    public boolean isRoot();
+    @Override
+    String getUri();
 
-    /** check to see if the term is obsolete, if it is it should not be used */
-    public boolean isTermObsolete();
+    boolean isRoot();
 
+    /**
+     * check to see if the term is obsolete, if it is it should not be used
+     */
+    boolean isTermObsolete();
 }

src/ubic/basecode/ontology/providers/AbstractOntologyService.java

@@ -50,7 +50,7 @@
  * @author kelsey
  */
 @SuppressWarnings("unused")
-public abstract class AbstractOntologyService {
+public abstract class AbstractOntologyService implements OntologyService {
 
     protected static Logger log = LoggerFactory.getLogger( AbstractOntologyService.class );
 
@@ -67,9 +67,7 @@ public abstract class AbstractOntologyService {
 
     private boolean isInitialized = false;
 
-    /**
-     * Initialize this ontology service.
-     */
+    @Override
     public void initialize( boolean forceLoad, boolean forceIndexing ) {
         if ( !forceLoad && isInitialized ) {
             log.warn( getOntologyName() + " is already loaded, and force=false, not restarting" );
@@ -155,9 +153,7 @@ public void closeIndex() {
         index.close();
     }
 
-    /**
-     * Looks for any OntologyIndividuals that match the given search string.
-     */
+    @Override
     public Collection<OntologyIndividual> findIndividuals( String search ) throws OntologySearchException {
         Lock lock = rwLock.readLock();
         try {
@@ -176,12 +172,7 @@ public Collection<OntologyIndividual> findIndividuals( String search ) throws On
         }
     }
 
-    /**
-     * Looks for any OntologyIndividuals or ontologyTerms that match the given search string
-     *
-     * @return results, or an empty collection if the results are empty OR the ontology is not available to be
-     * searched.
-     */
+    @Override
     public Collection<OntologyResource> findResources( String searchString ) throws OntologySearchException {
         Lock lock = rwLock.readLock();
         try {
@@ -200,9 +191,7 @@ public Collection<OntologyResource> findResources( String searchString ) throws
         }
     }
 
-    /**
-     * Looks for any ontologyTerms that match the given search string. Obsolete terms are filtered out.
-     */
+    @Override
     public Collection<OntologyTerm> findTerm( String search ) throws OntologySearchException {
         if ( log.isDebugEnabled() ) log.debug( "Searching " + getOntologyName() + " for '" + search + "'" );
         Lock lock = rwLock.readLock();
@@ -222,6 +211,7 @@ public Collection<OntologyTerm> findTerm( String search ) throws OntologySearchE
         }
     }
 
+    @Override
     public OntologyTerm findUsingAlternativeId( String alternativeId ) {
         Lock lock = alternativeIDs != null ? rwLock.readLock() : rwLock.writeLock();
         try {
@@ -241,6 +231,7 @@ public OntologyTerm findUsingAlternativeId( String alternativeId ) {
         }
     }
 
+    @Override
     public Set<String> getAllURIs() {
         Lock lock = rwLock.readLock();
         try {
@@ -264,10 +255,7 @@ public Set<String> getAllURIs() {
         }
     }
 
-    /**
-     * Looks through both Terms and Individuals for a OntologyResource that has a uri matching the uri given. If no
-     * OntologyTerm is found only then will ontologyIndividuals be searched. returns null if nothing is found.
-     */
+    @Override
     public OntologyResource getResource( String uri ) {
         if ( uri == null ) return null;
         Lock lock = rwLock.readLock();
@@ -297,9 +285,7 @@ public OntologyResource getResource( String uri ) {
         }
     }
 
-    /**
-     * Looks for a OntologyTerm that has the match in URI given
-     */
+    @Override
     public OntologyTerm getTerm( String uri ) {
         if ( uri == null ) throw new IllegalArgumentException( "URI cannot be null" );
         Lock lock = rwLock.readLock();
@@ -312,6 +298,7 @@ public OntologyTerm getTerm( String uri ) {
         }
     }
 
+    @Override
     public Collection<OntologyIndividual> getTermIndividuals( String uri ) {
         Lock lock = rwLock.readLock();
         try {
@@ -333,6 +320,7 @@ public Collection<OntologyIndividual> getTermIndividuals( String uri ) {
         }
     }
 
+    @Override
     public boolean isEnabled() {
         // quick path: just lookup the configuration
         String configParameter = "load." + getOntologyName();
@@ -349,28 +337,15 @@ public boolean isEnabled() {
         }
     }
 
-    /**
-     * Used for determining if the Ontology has finished loading into memory. Although calls like getParents,
-     * getChildren will still work (its much faster once the ontologies have been preloaded into memory.)
-     */
+    @Override
     public boolean isOntologyLoaded() {
         // it's fine not to use the read lock here
         return isInitialized;
     }
 
     private Thread initializationThread = null;
 
-    /**
-     * Start the initialization thread.
-     * <p>
-     * If the initialization thread is already running, this method does nothing. If the initialization thread
-     * previously completed, the ontology will be reinitialized.
-     *
-     * @param forceLoad     Force loading of ontology, even if it is already loaded
-     * @param forceIndexing If forceLoad is also true, indexing will be performed. If you know the index is
-     *                      up to date, there's no need to do it again. Normally indexing is only done if there is no
-     *                      index, or if the ontology has changed since last loaded.
-     */
+    @Override
     public synchronized void startInitializationThread( boolean forceLoad, boolean forceIndexing ) {
         if ( initializationThread != null && initializationThread.isAlive() ) {
             log.warn( String.format( " Initialization thread for %s is currently running, not restarting.", getOntologyName() ) );
@@ -394,27 +369,28 @@ public synchronized void startInitializationThread( boolean forceLoad, boolean f
         initializationThread.start();
     }
 
+    @Override
     public boolean isInitializationThreadAlive() {
         return initializationThread != null && initializationThread.isAlive();
     }
 
+    @Override
     public boolean isInitializationThreadCancelled() {
         return initializationThread != null && initializationThread.isInterrupted();
     }
 
     /**
      * Cancel the initialization thread.
      */
+    @Override
     public void cancelInitializationThread() {
         if ( initializationThread == null ) {
             throw new IllegalStateException( "The initialization thread has not started. Invoke startInitializationThread() first." );
         }
         initializationThread.interrupt();
     }
 
-    /**
-     * Wait for the initialization thread to finish.
-     */
+    @Override
     public void waitForInitializationThread() throws InterruptedException {
         if ( initializationThread == null ) {
             throw new IllegalStateException( "The initialization thread has not started. Invoke startInitializationThread() first." );
@@ -439,13 +415,7 @@ public void waitForInitializationThread() throws InterruptedException {
      */
     protected abstract OntModel loadModel();
 
-    /**
-     * Index the ontology for performing full-text searches.
-     *
-     * @see #findIndividuals(String)
-     * @see #findTerm(String)
-     * @see #findResources(String)
-     */
+    @Override
     public void index( boolean force ) {
         Lock lock = rwLock.writeLock();
         try {
@@ -504,13 +474,7 @@ private OntologyTerm getTermInternal( String uri ) {
         } );
     }
 
-    /**
-     * For testing! Overrides normal way of loading the ontology. This does not index the ontology unless 'force' is
-     * true (if there is an existing index, it will be used)
-     *
-     * @param is         input stream from which the ontology model is loaded
-     * @param forceIndex initialize the index. Otherwise it will only be initialized if it doesn't exist.
-     */
+    @Override
     public void loadTermsInNameSpace( InputStream is, boolean forceIndex ) {
         Lock lock = rwLock.writeLock();
         try {

src/ubic/basecode/ontology/providers/OntologyService.java

@@ -0,0 +1,103 @@
+package ubic.basecode.ontology.providers;
+
+import ubic.basecode.ontology.model.OntologyIndividual;
+import ubic.basecode.ontology.model.OntologyResource;
+import ubic.basecode.ontology.model.OntologyTerm;
+import ubic.basecode.ontology.search.OntologySearchException;
+
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.Set;
+
+public interface OntologyService {
+
+    /**
+     * Initialize this ontology service.
+     */
+    void initialize( boolean forceLoad, boolean forceIndexing );
+
+    /**
+     * Looks for any OntologyIndividuals that match the given search string.
+     */
+    Collection<OntologyIndividual> findIndividuals( String search ) throws OntologySearchException;
+
+    /**
+     * Looks for any OntologyIndividuals or ontologyTerms that match the given search string
+     *
+     * @return results, or an empty collection if the results are empty OR the ontology is not available to be
+     * searched.
+     */
+    Collection<OntologyResource> findResources( String searchString ) throws OntologySearchException;
+
+    /**
+     * Looks for any ontologyTerms that match the given search string. Obsolete terms are filtered out.
+     */
+    Collection<OntologyTerm> findTerm( String search ) throws OntologySearchException;
+
+    OntologyTerm findUsingAlternativeId( String alternativeId );
+
+    Set<String> getAllURIs();
+
+    /**
+     * Looks through both Terms and Individuals for a OntologyResource that has a uri matching the uri given. If no
+     * OntologyTerm is found only then will ontologyIndividuals be searched. returns null if nothing is found.
+     */
+    OntologyResource getResource( String uri );
+
+    /**
+     * Looks for a OntologyTerm that has the match in URI given
+     */
+    OntologyTerm getTerm( String uri );
+
+    Collection<OntologyIndividual> getTermIndividuals( String uri );
+
+    boolean isEnabled();
+
+    /**
+     * Used for determining if the Ontology has finished loading into memory. Although calls like getParents,
+     * getChildren will still work (its much faster once the ontologies have been preloaded into memory.)
+     */
+    boolean isOntologyLoaded();
+
+    /**
+     * Start the initialization thread.
+     * <p>
+     * If the initialization thread is already running, this method does nothing. If the initialization thread
+     * previously completed, the ontology will be reinitialized.
+     *
+     * @param forceLoad     Force loading of ontology, even if it is already loaded
+     * @param forceIndexing If forceLoad is also true, indexing will be performed. If you know the index is
+     *                      up to date, there's no need to do it again. Normally indexing is only done if there is no
+     *                      index, or if the ontology has changed since last loaded.
+     */
+    void startInitializationThread( boolean forceLoad, boolean forceIndexing );
+
+    boolean isInitializationThreadAlive();
+
+    boolean isInitializationThreadCancelled();
+
+    void cancelInitializationThread();
+
+    /**
+     * Wait for the initialization thread to finish.
+     */
+    void waitForInitializationThread() throws InterruptedException;
+
+    /**
+     * Index the ontology for performing full-text searches.
+     *
+     * @see #findIndividuals(String)
+     * @see #findTerm(String)
+     * @see #findResources(String)
+     */
+    void index( boolean force );
+
+    /**
+     * For testing! Overrides normal way of loading the ontology. This does not index the ontology unless 'force' is
+     * true (if there is an existing index, it will be used)
+     *
+     * @param is         input stream from which the ontology model is loaded
+     * @param forceIndex initialize the index. Otherwise it will only be initialized if it doesn't exist.
+     */
+    void loadTermsInNameSpace( InputStream is, boolean forceIndex );
+}