Index: java/org/apache/lucene/index/TermInfosReader.java =================================================================== --- java/org/apache/lucene/index/TermInfosReader.java (revision 933800) +++ java/org/apache/lucene/index/TermInfosReader.java (working copy) @@ -22,6 +22,7 @@ import org.apache.lucene.store.Directory; import org.apache.lucene.util.cache.Cache; import org.apache.lucene.util.cache.SimpleLRUCache; +import org.apache.lucene.util.AbstractFactory; import org.apache.lucene.util.CloseableThreadLocal; /** This stores a monotonically increasing set of pairs in a @@ -43,8 +44,6 @@ private final int totalIndexInterval; - private final static int DEFAULT_CACHE_SIZE = 1024; - /** * Per-thread resources managed by ThreadLocal */ @@ -143,7 +142,7 @@ resources = new ThreadResources(); resources.termEnum = terms(); // Cache does not have to be thread-safe, it is only used by one thread at the same time - resources.termInfoCache = new SimpleLRUCache(DEFAULT_CACHE_SIZE); + resources.termInfoCache = (Cache) AbstractFactory.getInstance().create(Cache.class); threadResources.set(resources); } return resources; Index: java/org/apache/lucene/search/CacheBackend.java =================================================================== --- java/org/apache/lucene/search/CacheBackend.java (revision 0) +++ java/org/apache/lucene/search/CacheBackend.java (revision 0) @@ -0,0 +1,7 @@ +package org.apache.lucene.search; + +import java.util.Map; + +public interface CacheBackend/* */extends Map /* ? */{ + +} Index: java/org/apache/lucene/search/DefaultCacheBackendFactory.java =================================================================== --- java/org/apache/lucene/search/DefaultCacheBackendFactory.java (revision 0) +++ java/org/apache/lucene/search/DefaultCacheBackendFactory.java (revision 0) @@ -0,0 +1,43 @@ +package org.apache.lucene.search; + +import org.apache.lucene.util.FactoryAdapter; + +public class DefaultCacheBackendFactory extends FactoryAdapter/* + * + */{ + + public static class Param { + public final boolean weak; + + public Param(boolean weakReferences) { + weak = weakReferences; + } + } + + public DefaultCacheBackendFactory() { + super(CacheBackend.class); + } + + private static class DefaultCacheBackendFactoryHolder { + private static final DefaultCacheBackendFactory INSTANCE = new DefaultCacheBackendFactory(); + } + + public static DefaultCacheBackendFactory getInstance() { + return DefaultCacheBackendFactoryHolder.INSTANCE; + } + + public CacheBackend create(DefaultCacheBackendFactory.Param param) { + if (null != param) { + if (param.weak) { + return new WeakHashMapCacheBackend(); + } + return new HashMapCacheBackend(); + } + return new WeakHashMapCacheBackend(); + } + + public Object create(Object param) { + return create((DefaultCacheBackendFactory.Param) param); + } +} Index: java/org/apache/lucene/search/FieldCacheImpl.java =================================================================== --- java/org/apache/lucene/search/FieldCacheImpl.java (revision 933800) +++ java/org/apache/lucene/search/FieldCacheImpl.java (working copy) @@ -32,6 +32,7 @@ import org.apache.lucene.index.Term; import org.apache.lucene.index.TermDocs; import org.apache.lucene.index.TermEnum; +import org.apache.lucene.util.AbstractFactory; import org.apache.lucene.util.StringHelper; import org.apache.lucene.util.FieldCacheSanityChecker; @@ -47,12 +48,12 @@ // TODO: change interface to FieldCache in 3.0 when removed class FieldCacheImpl implements ExtendedFieldCache { - private Map caches; + private Map/**/ caches; FieldCacheImpl() { init(); } private synchronized void init() { - caches = new HashMap(7); + caches = new HashMap/**/(7); caches.put(Byte.TYPE, new ByteCache(this)); caches.put(Short.TYPE, new ShortCache(this)); caches.put(Integer.TYPE, new IntCache(this)); @@ -70,11 +71,11 @@ } public CacheEntry[] getCacheEntries() { - List result = new ArrayList(17); - Iterator outerKeys = caches.keySet().iterator(); + List/**/ result = new ArrayList(17); + Iterator/**/ outerKeys = caches.keySet().iterator(); while (outerKeys.hasNext()) { - Class cacheType = (Class)outerKeys.next(); - Cache cache = (Cache)caches.get(cacheType); + Class cacheType = (Class) outerKeys.next(); + Cache cache = (Cache) caches.get(cacheType); Iterator innerKeys = cache.readerCache.keySet().iterator(); while (innerKeys.hasNext()) { // we've now materialized a hard ref @@ -178,19 +179,19 @@ final FieldCache wrapper; - final Map readerCache = new WeakHashMap(); + final CacheBackend/*>*/ readerCache = (CacheBackend) AbstractFactory.getInstance().create(CacheBackend.class); protected abstract Object createValue(IndexReader reader, Entry key) throws IOException; public Object get(IndexReader reader, Entry key) throws IOException { - Map innerCache; + CacheBackend/**/ innerCache; Object value; final Object readerKey = reader.getFieldCacheKey(); synchronized (readerCache) { - innerCache = (Map) readerCache.get(readerKey); + innerCache = (CacheBackend) readerCache.get(readerKey); if (innerCache == null) { - innerCache = new HashMap(); + innerCache = (CacheBackend) AbstractFactory.getInstance().create(CacheBackend.class); readerCache.put(readerKey, innerCache); value = null; } else { @@ -320,7 +321,7 @@ // inherit javadocs public byte[] getBytes(IndexReader reader, String field, ByteParser parser) throws IOException { - return (byte[]) ((Cache)caches.get(Byte.TYPE)).get(reader, new Entry(field, parser)); + return (byte[]) ((Cache) caches.get(Byte.TYPE)).get(reader, new Entry(field, parser)); } static final class ByteCache extends Cache { @@ -365,7 +366,7 @@ // inherit javadocs public short[] getShorts(IndexReader reader, String field, ShortParser parser) throws IOException { - return (short[]) ((Cache)caches.get(Short.TYPE)).get(reader, new Entry(field, parser)); + return (short[]) ((Cache) caches.get(Short.TYPE)).get(reader, new Entry(field, parser)); } static final class ShortCache extends Cache { @@ -411,7 +412,7 @@ // inherit javadocs public int[] getInts(IndexReader reader, String field, IntParser parser) throws IOException { - return (int[]) ((Cache)caches.get(Integer.TYPE)).get(reader, new Entry(field, parser)); + return (int[]) ((Cache) caches.get(Integer.TYPE)).get(reader, new Entry(field, parser)); } static final class IntCache extends Cache { @@ -468,7 +469,7 @@ public float[] getFloats(IndexReader reader, String field, FloatParser parser) throws IOException { - return (float[]) ((Cache)caches.get(Float.TYPE)).get(reader, new Entry(field, parser)); + return (float[]) ((Cache) caches.get(Float.TYPE)).get(reader, new Entry(field, parser)); } static final class FloatCache extends Cache { @@ -522,13 +523,13 @@ // inherit javadocs public long[] getLongs(IndexReader reader, String field, FieldCache.LongParser parser) throws IOException { - return (long[]) ((Cache)caches.get(Long.TYPE)).get(reader, new Entry(field, parser)); + return (long[]) ((Cache) caches.get(Long.TYPE)).get(reader, new Entry(field, parser)); } /** @deprecated Will be removed in 3.0, this is for binary compatibility only */ public long[] getLongs(IndexReader reader, String field, ExtendedFieldCache.LongParser parser) throws IOException { - return (long[]) ((Cache)caches.get(Long.TYPE)).get(reader, new Entry(field, parser)); + return (long[]) ((Cache) caches.get(Long.TYPE)).get(reader, new Entry(field, parser)); } static final class LongCache extends Cache { @@ -583,13 +584,13 @@ // inherit javadocs public double[] getDoubles(IndexReader reader, String field, FieldCache.DoubleParser parser) throws IOException { - return (double[]) ((Cache)caches.get(Double.TYPE)).get(reader, new Entry(field, parser)); + return (double[]) ((Cache) caches.get(Double.TYPE)).get(reader, new Entry(field, parser)); } /** @deprecated Will be removed in 3.0, this is for binary compatibility only */ public double[] getDoubles(IndexReader reader, String field, ExtendedFieldCache.DoubleParser parser) throws IOException { - return (double[]) ((Cache)caches.get(Double.TYPE)).get(reader, new Entry(field, parser)); + return (double[]) ((Cache) caches.get(Double.TYPE)).get(reader, new Entry(field, parser)); } static final class DoubleCache extends Cache { @@ -638,7 +639,7 @@ // inherit javadocs public String[] getStrings(IndexReader reader, String field) throws IOException { - return (String[]) ((Cache)caches.get(String.class)).get(reader, new Entry(field, (Parser)null)); + return (String[]) ((Cache) caches.get(String.class)).get(reader, new Entry(field, (Parser)null)); } static final class StringCache extends Cache { @@ -673,7 +674,7 @@ // inherit javadocs public StringIndex getStringIndex(IndexReader reader, String field) throws IOException { - return (StringIndex) ((Cache)caches.get(StringIndex.class)).get(reader, new Entry(field, (Parser)null)); + return (StringIndex) ((Cache) caches.get(StringIndex.class)).get(reader, new Entry(field, (Parser)null)); } static final class StringIndexCache extends Cache { @@ -750,7 +751,7 @@ // inherit javadocs public Object getAuto(IndexReader reader, String field) throws IOException { - return ((Cache)caches.get(Object.class)).get(reader, new Entry(field, (Parser)null)); + return ((Cache) caches.get(Object.class)).get(reader, new Entry(field, (Parser)null)); } /** @@ -805,7 +806,7 @@ /** @deprecated */ public Comparable[] getCustom(IndexReader reader, String field, SortComparator comparator) throws IOException { - return (Comparable[]) ((Cache)caches.get(Comparable.class)).get(reader, new Entry(field, comparator)); + return (Comparable[]) ((Cache) caches.get(Comparable.class)).get(reader, new Entry(field, comparator)); } /** @deprecated */ Index: java/org/apache/lucene/search/HashMapCacheBackend.java =================================================================== --- java/org/apache/lucene/search/HashMapCacheBackend.java (revision 0) +++ java/org/apache/lucene/search/HashMapCacheBackend.java (revision 0) @@ -0,0 +1,8 @@ +package org.apache.lucene.search; + +import java.util.HashMap; + +public class HashMapCacheBackend/* */extends HashMap implements + CacheBackend { + +} Index: java/org/apache/lucene/search/WeakHashMapCacheBackend.java =================================================================== --- java/org/apache/lucene/search/WeakHashMapCacheBackend.java (revision 0) +++ java/org/apache/lucene/search/WeakHashMapCacheBackend.java (revision 0) @@ -0,0 +1,8 @@ +package org.apache.lucene.search; + +import java.util.WeakHashMap; + +public class WeakHashMapCacheBackend/* */extends WeakHashMap implements + CacheBackend { + +} Index: java/org/apache/lucene/util/AbstractFactory.java =================================================================== --- java/org/apache/lucene/util/AbstractFactory.java (revision 0) +++ java/org/apache/lucene/util/AbstractFactory.java (revision 0) @@ -0,0 +1,38 @@ +package org.apache.lucene.util; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.apache.lucene.search.DefaultCacheBackendFactory; +import org.apache.lucene.util.cache.DefaultCacheFactory; + +public class AbstractFactory { + + private Map factories/* */= new ConcurrentHashMap(); + + private AbstractFactory() { + registerFactory(DefaultCacheFactory.getInstance()); + registerFactory(DefaultCacheBackendFactory.getInstance()); + } + + private static class AbstractFactoryHolder { + private static final AbstractFactory INSTANCE = new AbstractFactory(); + } + + public static AbstractFactory getInstance() { + return AbstractFactoryHolder.INSTANCE; + } + + public void registerFactory(Factory factory) { + factories.put(factory.getKeyInterface(), factory); + } + + public Object create(Class keyInterface) { + return ((Factory) factories.get(keyInterface)).create(); + } + + public Object create(Class keyInterface, Object param) { + return ((Factory) factories.get(keyInterface)).create(param); + } + +} Index: java/org/apache/lucene/util/Factory.java =================================================================== --- java/org/apache/lucene/util/Factory.java (revision 0) +++ java/org/apache/lucene/util/Factory.java (revision 0) @@ -0,0 +1,11 @@ +package org.apache.lucene.util; + +public interface Factory { + + public Class getKeyInterface(); + + public Object create(Object param); + + public Object create(); + +} Index: java/org/apache/lucene/util/FactoryAdapter.java =================================================================== --- java/org/apache/lucene/util/FactoryAdapter.java (revision 0) +++ java/org/apache/lucene/util/FactoryAdapter.java (revision 0) @@ -0,0 +1,19 @@ +package org.apache.lucene.util; + +public abstract class FactoryAdapter implements Factory { + + private final Class keyInterface; + + public FactoryAdapter(Class keyInterface) { + this.keyInterface = keyInterface; + } + + public Object create() { + return create(null); + } + + public Class getKeyInterface() { + return keyInterface; + } + +} Index: java/org/apache/lucene/util/cache/DefaultCacheFactory.java =================================================================== --- java/org/apache/lucene/util/cache/DefaultCacheFactory.java (revision 0) +++ java/org/apache/lucene/util/cache/DefaultCacheFactory.java (revision 0) @@ -0,0 +1,53 @@ +package org.apache.lucene.util.cache; + +import org.apache.lucene.util.FactoryAdapter; + +public class DefaultCacheFactory extends FactoryAdapter/* + * + */{ + + public final static int DEFAULT_CACHE_SIZE = 1024; + + public static class Params { + + public final boolean sync; + + public final int size; + + public Params(boolean sync, int size) { + this.sync = sync; + this.size = size; + } + + } + + private DefaultCacheFactory() { + super(Cache.class); + } + + private static class DefaultCacheFactoryHolder { + private static final DefaultCacheFactory INSTANCE = new DefaultCacheFactory(); + } + + public static DefaultCacheFactory getInstance() { + return DefaultCacheFactoryHolder.INSTANCE; + } + + public Cache create(Params params) { + if (params != null) { + SimpleLRUCache cache = new SimpleLRUCache(params.size); + if (params.sync) { + return Cache.synchronizedCache(cache); + } + return cache; + } + return new SimpleLRUCache(DEFAULT_CACHE_SIZE); + } + + public Object create(Object param) { + return create((DefaultCacheFactory.Params) param); + } + +}