X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/FieldCacheImpl.java

diff --git a/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/FieldCacheImpl.java b/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/FieldCacheImpl.java
deleted file mode 100644
index 8906d9b..0000000
--- a/lucene-java-3.4.0/lucene/src/java/org/apache/lucene/search/FieldCacheImpl.java
+++ /dev/null
@@ -1,745 +0,0 @@
-package org.apache.lucene.search;
-
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import java.io.IOException;
-import java.io.PrintStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.WeakHashMap;
-
-import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.index.Term;
-import org.apache.lucene.index.TermDocs;
-import org.apache.lucene.index.TermEnum;
-import org.apache.lucene.util.BitVector;
-import org.apache.lucene.util.DocIdBitSet;
-import org.apache.lucene.util.OpenBitSet;
-import org.apache.lucene.util.StringHelper;
-import org.apache.lucene.util.FieldCacheSanityChecker;
-
-/**
- * Expert: The default cache implementation, storing all values in memory.
- * A WeakHashMap is used for storage.
- *
- * <p>Created: May 19, 2004 4:40:36 PM
- *
- * @since   lucene 1.4
- */
-class FieldCacheImpl implements FieldCache {
-	
-  private Map<Class<?>,Cache> caches;
-  FieldCacheImpl() {
-    init();
-  }
-  private synchronized void init() {
-    caches = new HashMap<Class<?>,Cache>(9);
-    caches.put(Byte.TYPE, new ByteCache(this));
-    caches.put(Short.TYPE, new ShortCache(this));
-    caches.put(Integer.TYPE, new IntCache(this));
-    caches.put(Float.TYPE, new FloatCache(this));
-    caches.put(Long.TYPE, new LongCache(this));
-    caches.put(Double.TYPE, new DoubleCache(this));
-    caches.put(String.class, new StringCache(this));
-    caches.put(StringIndex.class, new StringIndexCache(this));
-    caches.put(UnValuedDocsCache.class, new UnValuedDocsCache(this));
-  }
-
-  public synchronized void purgeAllCaches() {
-    init();
-  }
-
-  public synchronized void purge(IndexReader r) {
-    for(Cache c : caches.values()) {
-      c.purge(r);
-    }
-  }
-  
-  public synchronized CacheEntry[] getCacheEntries() {
-    List<CacheEntry> result = new ArrayList<CacheEntry>(17);
-    for(final Map.Entry<Class<?>,Cache> cacheEntry: caches.entrySet()) {
-      final Cache cache = cacheEntry.getValue();
-      final Class<?> cacheType = cacheEntry.getKey();
-      synchronized(cache.readerCache) {
-        for (final Map.Entry<Object,Map<Entry, Object>> readerCacheEntry : cache.readerCache.entrySet()) {
-          final Object readerKey = readerCacheEntry.getKey();
-          if (readerKey == null) continue;
-          final Map<Entry, Object> innerCache = readerCacheEntry.getValue();
-          for (final Map.Entry<Entry, Object> mapEntry : innerCache.entrySet()) {
-            Entry entry = mapEntry.getKey();
-            result.add(new CacheEntryImpl(readerKey, entry.field,
-                                          cacheType, entry.custom,
-                                          mapEntry.getValue()));
-          }
-        }
-      }
-    }
-    return result.toArray(new CacheEntry[result.size()]);
-  }
-  
-  private static final class CacheEntryImpl extends CacheEntry {
-    private final Object readerKey;
-    private final String fieldName;
-    private final Class<?> cacheType;
-    private final Object custom;
-    private final Object value;
-    CacheEntryImpl(Object readerKey, String fieldName,
-                   Class<?> cacheType,
-                   Object custom,
-                   Object value) {
-        this.readerKey = readerKey;
-        this.fieldName = fieldName;
-        this.cacheType = cacheType;
-        this.custom = custom;
-        this.value = value;
-
-        // :HACK: for testing.
-//         if (null != locale || SortField.CUSTOM != sortFieldType) {
-//           throw new RuntimeException("Locale/sortFieldType: " + this);
-//         }
-
-    }
-    @Override
-    public Object getReaderKey() { return readerKey; }
-    @Override
-    public String getFieldName() { return fieldName; }
-    @Override
-    public Class<?> getCacheType() { return cacheType; }
-    @Override
-    public Object getCustom() { return custom; }
-    @Override
-    public Object getValue() { return value; }
-  }
-
-  /**
-   * Hack: When thrown from a Parser (NUMERIC_UTILS_* ones), this stops
-   * processing terms and returns the current FieldCache
-   * array.
-   */
-  static final class StopFillCacheException extends RuntimeException {
-  }
-
-  final static IndexReader.ReaderFinishedListener purgeReader = new IndexReader.ReaderFinishedListener() {
-    // @Override -- not until Java 1.6
-    public void finished(IndexReader reader) {
-      FieldCache.DEFAULT.purge(reader);
-    }
-  };
-
-  /** Expert: Internal cache. */
-  abstract static class Cache {
-    Cache() {
-      this.wrapper = null;
-    }
-
-    Cache(FieldCache wrapper) {
-      this.wrapper = wrapper;
-    }
-
-    final FieldCache wrapper;
-
-    final Map<Object,Map<Entry,Object>> readerCache = new WeakHashMap<Object,Map<Entry,Object>>();
-    
-    protected abstract Object createValue(IndexReader reader, Entry key)
-        throws IOException;
-
-    /** Remove this reader from the cache, if present. */
-    public void purge(IndexReader r) {
-      Object readerKey = r.getCoreCacheKey();
-      synchronized(readerCache) {
-        readerCache.remove(readerKey);
-      }
-    }
-
-    public Object get(IndexReader reader, Entry key) throws IOException {
-      Map<Entry,Object> innerCache;
-      Object value;
-      final Object readerKey = reader.getCoreCacheKey();
-      synchronized (readerCache) {
-        innerCache = readerCache.get(readerKey);
-        if (innerCache == null) {
-          // First time this reader is using FieldCache
-          innerCache = new HashMap<Entry,Object>();
-          readerCache.put(readerKey, innerCache);
-          reader.addReaderFinishedListener(purgeReader);
-          value = null;
-        } else {
-          value = innerCache.get(key);
-        }
-        if (value == null) {
-          value = new CreationPlaceholder();
-          innerCache.put(key, value);
-        }
-      }
-      if (value instanceof CreationPlaceholder) {
-        synchronized (value) {
-          CreationPlaceholder progress = (CreationPlaceholder) value;
-          if (progress.value == null) {
-            progress.value = createValue(reader, key);
-            synchronized (readerCache) {
-              innerCache.put(key, progress.value);
-            }
-
-            // Only check if key.custom (the parser) is
-            // non-null; else, we check twice for a single
-            // call to FieldCache.getXXX
-            if (key.custom != null && wrapper != null) {
-              final PrintStream infoStream = wrapper.getInfoStream();
-              if (infoStream != null) {
-                printNewInsanity(infoStream, progress.value);
-              }
-            }
-          }
-          return progress.value;
-        }
-      }
-      return value;
-    }
-
-    private void printNewInsanity(PrintStream infoStream, Object value) {
-      final FieldCacheSanityChecker.Insanity[] insanities = FieldCacheSanityChecker.checkSanity(wrapper);
-      for(int i=0;i<insanities.length;i++) {
-        final FieldCacheSanityChecker.Insanity insanity = insanities[i];
-        final CacheEntry[] entries = insanity.getCacheEntries();
-        for(int j=0;j<entries.length;j++) {
-          if (entries[j].getValue() == value) {
-            // OK this insanity involves our entry
-            infoStream.println("WARNING: new FieldCache insanity created\nDetails: " + insanity.toString());
-            infoStream.println("\nStack:\n");
-            new Throwable().printStackTrace(infoStream);
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  /** Expert: Every composite-key in the internal cache is of this type. */
-  static class Entry {
-    final String field;        // which Fieldable
-    final Object custom;       // which custom comparator or parser
-
-    /** Creates one of these objects for a custom comparator/parser. */
-    Entry (String field, Object custom) {
-      this.field = StringHelper.intern(field);
-      this.custom = custom;
-    }
-
-    /** Two of these are equal iff they reference the same field and type. */
-    @Override
-    public boolean equals (Object o) {
-      if (o instanceof Entry) {
-        Entry other = (Entry) o;
-        if (other.field == field) {
-          if (other.custom == null) {
-            if (custom == null) return true;
-          } else if (other.custom.equals (custom)) {
-            return true;
-          }
-        }
-      }
-      return false;
-    }
-
-    /** Composes a hashcode based on the field and type. */
-    @Override
-    public int hashCode() {
-      return field.hashCode() ^ (custom==null ? 0 : custom.hashCode());
-    }
-  }
-
-  // inherit javadocs
-  public byte[] getBytes (IndexReader reader, String field) throws IOException {
-    return getBytes(reader, field, null);
-  }
-
-  // inherit javadocs
-  public byte[] getBytes(IndexReader reader, String field, ByteParser parser)
-      throws IOException {
-    return (byte[]) caches.get(Byte.TYPE).get(reader, new Entry(field, parser));
-  }
-
-  static final class ByteCache extends Cache {
-    ByteCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-        throws IOException {
-      Entry entry = entryKey;
-      String field = entry.field;
-      ByteParser parser = (ByteParser) entry.custom;
-      if (parser == null) {
-        return wrapper.getBytes(reader, field, FieldCache.DEFAULT_BYTE_PARSER);
-      }
-      final byte[] retArray = new byte[reader.maxDoc()];
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          byte termval = parser.parseByte(term.text());
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = termval;
-          }
-        } while (termEnum.next());
-      } catch (StopFillCacheException stop) {
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      return retArray;
-    }
-  }
-  
-  // inherit javadocs
-  public short[] getShorts (IndexReader reader, String field) throws IOException {
-    return getShorts(reader, field, null);
-  }
-
-  // inherit javadocs
-  public short[] getShorts(IndexReader reader, String field, ShortParser parser)
-      throws IOException {
-    return (short[]) caches.get(Short.TYPE).get(reader, new Entry(field, parser));
-  }
-
-  static final class ShortCache extends Cache {
-    ShortCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-        throws IOException {
-      Entry entry =  entryKey;
-      String field = entry.field;
-      ShortParser parser = (ShortParser) entry.custom;
-      if (parser == null) {
-        return wrapper.getShorts(reader, field, FieldCache.DEFAULT_SHORT_PARSER);
-      }
-      final short[] retArray = new short[reader.maxDoc()];
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          short termval = parser.parseShort(term.text());
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = termval;
-          }
-        } while (termEnum.next());
-      } catch (StopFillCacheException stop) {
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      return retArray;
-    }
-  }
-  
-  // inherit javadocs
-  public int[] getInts (IndexReader reader, String field) throws IOException {
-    return getInts(reader, field, null);
-  }
-
-  // inherit javadocs
-  public int[] getInts(IndexReader reader, String field, IntParser parser)
-      throws IOException {
-    return (int[]) caches.get(Integer.TYPE).get(reader, new Entry(field, parser));
-  }
-
-  static final class IntCache extends Cache {
-    IntCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-        throws IOException {
-      Entry entry = entryKey;
-      String field = entry.field;
-      IntParser parser = (IntParser) entry.custom;
-      if (parser == null) {
-        try {
-          return wrapper.getInts(reader, field, DEFAULT_INT_PARSER);
-        } catch (NumberFormatException ne) {
-          return wrapper.getInts(reader, field, NUMERIC_UTILS_INT_PARSER);      
-        }
-      }
-      int[] retArray = null;
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          int termval = parser.parseInt(term.text());
-          if (retArray == null) // late init
-            retArray = new int[reader.maxDoc()];
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = termval;
-          }
-        } while (termEnum.next());
-      } catch (StopFillCacheException stop) {
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      if (retArray == null) // no values
-        retArray = new int[reader.maxDoc()];
-      return retArray;
-    }
-  }
-
-  static final class UnValuedDocsCache extends Cache {
-    UnValuedDocsCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-    
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-    throws IOException {
-      Entry entry = entryKey;
-      String field = entry.field;
-      
-      if (reader.maxDoc() == reader.docFreq(new Term(field))) {
-        return DocIdSet.EMPTY_DOCIDSET;
-      }
-      
-      OpenBitSet res = new OpenBitSet(reader.maxDoc());
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            res.fastSet(termDocs.doc());
-          }
-        } while (termEnum.next());
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      res.flip(0, reader.maxDoc());
-      return res;
-    }
-  }
-  
-
-  // inherit javadocs
-  public float[] getFloats (IndexReader reader, String field)
-    throws IOException {
-    return getFloats(reader, field, null);
-  }
-
-  // inherit javadocs
-  public float[] getFloats(IndexReader reader, String field, FloatParser parser)
-    throws IOException {
-
-    return (float[]) caches.get(Float.TYPE).get(reader, new Entry(field, parser));
-  }
-
-  static final class FloatCache extends Cache {
-    FloatCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-        throws IOException {
-      Entry entry = entryKey;
-      String field = entry.field;
-      FloatParser parser = (FloatParser) entry.custom;
-      if (parser == null) {
-        try {
-          return wrapper.getFloats(reader, field, DEFAULT_FLOAT_PARSER);
-        } catch (NumberFormatException ne) {
-          return wrapper.getFloats(reader, field, NUMERIC_UTILS_FLOAT_PARSER);      
-        }
-    }
-      float[] retArray = null;
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          float termval = parser.parseFloat(term.text());
-          if (retArray == null) // late init
-            retArray = new float[reader.maxDoc()];
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = termval;
-          }
-        } while (termEnum.next());
-      } catch (StopFillCacheException stop) {
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      if (retArray == null) // no values
-        retArray = new float[reader.maxDoc()];
-      return retArray;
-    }
-  }
-
-
-  public long[] getLongs(IndexReader reader, String field) throws IOException {
-    return getLongs(reader, field, null);
-  }
-  
-  // inherit javadocs
-  public long[] getLongs(IndexReader reader, String field, FieldCache.LongParser parser)
-      throws IOException {
-    return (long[]) caches.get(Long.TYPE).get(reader, new Entry(field, parser));
-  }
-
-  static final class LongCache extends Cache {
-    LongCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-
-    @Override
-    protected Object createValue(IndexReader reader, Entry entry)
-        throws IOException {
-      String field = entry.field;
-      FieldCache.LongParser parser = (FieldCache.LongParser) entry.custom;
-      if (parser == null) {
-        try {
-          return wrapper.getLongs(reader, field, DEFAULT_LONG_PARSER);
-        } catch (NumberFormatException ne) {
-          return wrapper.getLongs(reader, field, NUMERIC_UTILS_LONG_PARSER);      
-        }
-      }
-      long[] retArray = null;
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term(field));
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          long termval = parser.parseLong(term.text());
-          if (retArray == null) // late init
-            retArray = new long[reader.maxDoc()];
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = termval;
-          }
-        } while (termEnum.next());
-      } catch (StopFillCacheException stop) {
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      if (retArray == null) // no values
-        retArray = new long[reader.maxDoc()];
-      return retArray;
-    }
-  }
-
-  // inherit javadocs
-  public double[] getDoubles(IndexReader reader, String field)
-    throws IOException {
-    return getDoubles(reader, field, null);
-  }
-
-  // inherit javadocs
-  public double[] getDoubles(IndexReader reader, String field, FieldCache.DoubleParser parser)
-      throws IOException {
-    return (double[]) caches.get(Double.TYPE).get(reader, new Entry(field, parser));
-  }
-
-  static final class DoubleCache extends Cache {
-    DoubleCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-        throws IOException {
-      Entry entry = entryKey;
-      String field = entry.field;
-      FieldCache.DoubleParser parser = (FieldCache.DoubleParser) entry.custom;
-      if (parser == null) {
-        try {
-          return wrapper.getDoubles(reader, field, DEFAULT_DOUBLE_PARSER);
-        } catch (NumberFormatException ne) {
-          return wrapper.getDoubles(reader, field, NUMERIC_UTILS_DOUBLE_PARSER);      
-        }
-      }
-      double[] retArray = null;
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          double termval = parser.parseDouble(term.text());
-          if (retArray == null) // late init
-            retArray = new double[reader.maxDoc()];
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = termval;
-          }
-        } while (termEnum.next());
-      } catch (StopFillCacheException stop) {
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      if (retArray == null) // no values
-        retArray = new double[reader.maxDoc()];
-      return retArray;
-    }
-  }
-
-  // inherit javadocs
-  public String[] getStrings(IndexReader reader, String field)
-      throws IOException {
-    return (String[]) caches.get(String.class).get(reader, new Entry(field, (Parser)null));
-  }
-
-  static final class StringCache extends Cache {
-    StringCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-        throws IOException {
-      String field = StringHelper.intern(entryKey.field);
-      final String[] retArray = new String[reader.maxDoc()];
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      final int termCountHardLimit = reader.maxDoc();
-      int termCount = 0;
-      try {
-        do {
-          if (termCount++ == termCountHardLimit) {
-            // app is misusing the API (there is more than
-            // one term per doc); in this case we make best
-            // effort to load what we can (see LUCENE-2142)
-            break;
-          }
-
-          Term term = termEnum.term();
-          if (term==null || term.field() != field) break;
-          String termval = term.text();
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = termval;
-          }
-        } while (termEnum.next());
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-      return retArray;
-    }
-  }
-
-  // inherit javadocs
-  public StringIndex getStringIndex(IndexReader reader, String field)
-      throws IOException {
-    return (StringIndex) caches.get(StringIndex.class).get(reader, new Entry(field, (Parser)null));
-  }
-
-  static final class StringIndexCache extends Cache {
-    StringIndexCache(FieldCache wrapper) {
-      super(wrapper);
-    }
-
-    @Override
-    protected Object createValue(IndexReader reader, Entry entryKey)
-        throws IOException {
-      String field = StringHelper.intern(entryKey.field);
-      final int[] retArray = new int[reader.maxDoc()];
-      String[] mterms = new String[reader.maxDoc()+1];
-      TermDocs termDocs = reader.termDocs();
-      TermEnum termEnum = reader.terms (new Term (field));
-      int t = 0;  // current term number
-
-      // an entry for documents that have no terms in this field
-      // should a document with no terms be at top or bottom?
-      // this puts them at the top - if it is changed, FieldDocSortedHitQueue
-      // needs to change as well.
-      mterms[t++] = null;
-
-      try {
-        do {
-          Term term = termEnum.term();
-          if (term==null || term.field() != field || t >= mterms.length) break;
-
-          // store term text
-          mterms[t] = term.text();
-
-          termDocs.seek (termEnum);
-          while (termDocs.next()) {
-            retArray[termDocs.doc()] = t;
-          }
-
-          t++;
-        } while (termEnum.next());
-      } finally {
-        termDocs.close();
-        termEnum.close();
-      }
-
-      if (t == 0) {
-        // if there are no terms, make the term array
-        // have a single null entry
-        mterms = new String[1];
-      } else if (t < mterms.length) {
-        // if there are less terms than documents,
-        // trim off the dead array space
-        String[] terms = new String[t];
-        System.arraycopy (mterms, 0, terms, 0, t);
-        mterms = terms;
-      }
-
-      StringIndex value = new StringIndex (retArray, mterms);
-      return value;
-    }
-  }
-
-  private volatile PrintStream infoStream;
-
-  public void setInfoStream(PrintStream stream) {
-    infoStream = stream;
-  }
-
-  public PrintStream getInfoStream() {
-    return infoStream;
-  }
-  
-  public DocIdSet getUnValuedDocs(IndexReader reader, String field)
-      throws IOException {
-    return (DocIdSet) caches.get(UnValuedDocsCache.class).get(reader, new Entry(field, null));  
-  }
-}
-