org.biojavax.RichObjectFactory Maven / Gradle / Ivy
/*
* BioJava development code
*
* This code may be freely distributed and modified under the
* terms of the GNU Lesser General Public Licence. This should
* be distributed with the code. If you do not have a copy,
* see:
*
* http://www.gnu.org/copyleft/lesser.html
*
* Copyright for this code is held jointly by the individual
* authors. These should be listed in @author doc comments.
*
* For more information on the BioJava project and its aims,
* or to join the biojava-l mailing list, visit the home page
* at:
*
* http://www.biojava.org/
*
*/
package org.biojavax;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.biojavax.bio.seq.DummyRichSequenceHandler;
import org.biojavax.bio.seq.PositionResolver;
import org.biojavax.bio.seq.RichSequenceHandler;
import org.biojavax.bio.seq.PositionResolver.AverageResolver;
import org.biojavax.ontology.ComparableOntology;
import org.biojavax.ontology.SimpleComparableOntology;
/**
* Runs a service that builds rich objects, and provides some default values
* for things like default ontology, default namespace, etc.
* @author Richard Holland
* @since 1.5
*/
public class RichObjectFactory {
private static RichObjectBuilder builder = new SimpleRichObjectBuilder();
private static String defaultOntologyName = "biojavax";
private static String defaultNamespaceName = "lcl";
private static PositionResolver defaultPositionResolver = new AverageResolver();
private static CrossReferenceResolver defaultCrossRefResolver = new DummyCrossReferenceResolver();
private static RichSequenceHandler defaultRichSequenceHandler = new DummyRichSequenceHandler();
// the LRU cache - keys are classes, entries are maps of param sets to objects
private static int defaultLRUcacheSize = 20;
private static Map LRUcacheSizes = new HashMap();
private static Map cache = new HashMap();
private final static Map applicationClassMap = new HashMap();
// Constructor is private as this is all static.
private RichObjectFactory() {}
/**
* Sets the builder to use when instantiating new Rich objects. The basic,
* default, one is a SimpleRichObjectBuilder, which just calls the constructor.
* Another useful one is BioSQLRichObjectBuilder, which attempts to load
* objects from the database. The latter is required if you are working with
* Hibernate as it will not work without it.
* @param b the builder to use.
* @see SimpleRichObjectBuilder
* @see org.biojavax.bio.db.biosql.BioSQLRichObjectBuilder
*/
public static synchronized void setRichObjectBuilder(RichObjectBuilder b) {
builder = b;
}
/**
* Delegates to a RichObjectBuilder to construct/retrieve the object, and returns it.
* To increase efficiency, it keeps a list of recently requested objects. If it
* receives further requests for the same object, it returns them from the cache. The
* size of the cache can be altered using setLRUCacheSize(). The default cache size is 20
* objects for each type of class requested.
* @param clazz the class to build
* @param params the parameters to pass to the class' constructor
* @return the instantiated object
*/
public static synchronized Object getObject(final Class clazz, Object[] params) {
List paramsList = Arrays.asList(params);
final Class applicationClass = getApplicationClass(clazz);
if (!cache.containsKey(applicationClass)) {
int LRUcacheSize = defaultLRUcacheSize;
if (LRUcacheSizes.containsKey(applicationClass)) LRUcacheSize = ((Integer)LRUcacheSizes.get(applicationClass)).intValue();
else LRUcacheSizes.put(applicationClass,new Integer(LRUcacheSize));
cache.put(applicationClass, new LinkedHashMap(LRUcacheSize, 0.75f, true) {
protected boolean removeEldestEntry(Map.Entry eldest) {
return this.size() > ((Integer)LRUcacheSizes.get(applicationClass)).intValue();
}
});
}
Map m = (Map)cache.get(applicationClass);
if (!m.containsKey(paramsList)) {
m.put(paramsList,builder.buildObject(applicationClass, paramsList));
}
return m.get(paramsList);
}
private final static Map getApplicationClassMap() {
return applicationClassMap;
}
/**
* Allow application to override the default biojava class created in getObject - subclass restriction is checked in the builder.
* @param theBiojavaClass one of the well-known builder classes: SimpleNamespace, SimpleComparableOntology, SimpleNCBITaxon, SimpleCrossRef, or SimpleDocRef
* @param theApplicationClass - a subclass of theBiojavaClass
*/
public final static void setApplicationClass(final Class theBiojavaClass, final Class theApplicationClass) {
if (theApplicationClass==null || theBiojavaClass.isAssignableFrom(theApplicationClass) == false) throw new IllegalArgumentException("RichObjectFactory.setApplicationClass-theApplicationClass: <"+theApplicationClass+"> must be assignable to the biojava class: <"+theBiojavaClass+">");
getApplicationClassMap().put(theBiojavaClass, theApplicationClass);
}
private final static Class getApplicationClass(final Class theBiojavaClass) {
final Class applicationClass = (Class) getApplicationClassMap().get(theBiojavaClass);
return applicationClass!=null?applicationClass:theBiojavaClass;
}
/**
* Removes all objects from the LRU cache.
*/
public static synchronized void clearLRUCache(){
cache.clear();
}
/**
* Removes all objects of the specified class from the LRU cache.
* @param clazz The class of the objects to remove.
*/
public static synchronized void clearLRUCache(Class clazz){
cache.remove(clazz);
}
/**
* Sets the size of the LRU cache. This is the size per class of object requested, so
* if you set it to 20 and request 3 different types of object, you will get 20*3=60
* entries in the cache. The default cache size is 20. Setting this value will undo
* any previous changes made using the setLRUCacheSize(Class,int) method below, but will not
* override future ones.
* @param size the size of the cache.
*/
public static void setLRUCacheSize(int size) {
defaultLRUcacheSize = size;
for (Iterator i = LRUcacheSizes.keySet().iterator(); i.hasNext(); ) LRUcacheSizes.put(i.next(), new Integer(size));
}
/**
* Sets the size of the LRU cache. This is the size for the specific class of object
* requested, so does not affect the size of caches of other objects.
* If this method is not called, then the cache size defaults to 20, or whatever value
* was passed to setLRUCacheSize(int) above.
* @param size the size of the cache.
*/
public static void setLRUCacheSize(Class clazz, int size) {
LRUcacheSizes.put(clazz,new Integer(size));
}
/**
* Sets the default namespace name to use when loading sequences. Defaults to "lcl".
* @param name the namespace name to use.
*/
public static void setDefaultNamespaceName(String name) { defaultNamespaceName = name; }
/**
* Sets the default ontology name to use when loading sequences. Defaults to "biojavax".
* @param name the ontology name to use.
*/
public static void setDefaultOntologyName(String name) { defaultOntologyName = name; }
/**
* Sets the default position resolver to use when creating new rich feature locations.
* Defaults to the AverageResolver
* @param pr the position resolver to use.
* @see org.biojavax.bio.seq.PositionResolver
* @see org.biojavax.bio.seq.PositionResolver.AverageResolver
* @see org.biojavax.bio.seq.RichLocation
*/
public static void setDefaultPositionResolver(PositionResolver pr) { defaultPositionResolver = pr; }
/**
* Sets the default crossref resolver to use when resolving remote entries.
* Defaults to the DummyCrossReferenceResolver.
* @param crr the resolver to use.
* @see org.biojavax.CrossReferenceResolver
* @see org.biojavax.DummyCrossReferenceResolver
*/
public static void setDefaultCrossReferenceResolver(CrossReferenceResolver crr) { defaultCrossRefResolver = crr; }
/**
* Sets the default sequence handler to use when performing sequence manipulation.
* Defaults to the DummyRichSequenceHandler.
* @param rsh the resolver to use.
* @see org.biojavax.bio.seq.RichSequenceHandler
* @see org.biojavax.bio.seq.DummyRichSequenceHandler
*/
public static void setDefaultRichSequenceHandler(RichSequenceHandler rsh) { defaultRichSequenceHandler = rsh; }
/**
* Returns the default namespace object. Defaults to "lcl".
* @return the default namespace.
*/
public static Namespace getDefaultNamespace() {
return (Namespace)getObject(SimpleNamespace.class, new Object[]{defaultNamespaceName});
}
/**
* Returns the default ontology object. Defaults to "biojavax".
* @return the default ontology.
*/
public static ComparableOntology getDefaultOntology() {
return (ComparableOntology)getObject(SimpleComparableOntology.class, new Object[]{defaultOntologyName});
}
/**
* Returns the default position resolver object. Defaults to PositionResolver.AverageResolver
* @return the default position resolver.
* @see org.biojavax.bio.seq.PositionResolver.AverageResolver
*/
public static PositionResolver getDefaultPositionResolver() { return defaultPositionResolver; }
/**
* Returns the default cross ref resolver object. Defaults to DummyCrossReferenceResolver
* @return the default resolver.
* @see org.biojavax.DummyCrossReferenceResolver
*/
public static CrossReferenceResolver getDefaultCrossReferenceResolver() { return defaultCrossRefResolver; }
/**
* Returns the default sequence resolver object. Defaults to DummyRichSequenceHandler.
* @return the default resolver.
* @see org.biojavax.bio.seq.DummyRichSequenceHandler
*/
public static RichSequenceHandler getDefaultRichSequenceHandler() { return defaultRichSequenceHandler; }
// commenting out for the moment, since it prevents core from compiling.
// TODO: move to BioSql module
// /**
// * A utility method that configures the RichObjectFactory for use with a Hibernate session.
// * @param session an object containing a Hibernate session.
// */
// public static void connectToBioSQL(Object session) {
// clearLRUCache();
// RichObjectFactory.setRichObjectBuilder(new BioSQLRichObjectBuilder(session));
// RichObjectFactory.setDefaultCrossReferenceResolver(new BioSQLCrossReferenceResolver(session));
// RichObjectFactory.setDefaultRichSequenceHandler(new BioSQLRichSequenceHandler(session));
// }
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy