IndexReader reader = ((IndexReader)fieldToReader.get(field));    if (reader != null) {      reader.getTermFreqVector(docNumber, field, mapper);     }  }  public void getTermFreqVector(int docNumber, TermVectorMapper mapper) throws IOException {    ensureOpen();    ensureOpen();    Iterator i = fieldToReader.entrySet().iterator();    while (i.hasNext()) {      Map.Entry e = (Map.Entry)i.next();      String field = (String)e.getKey();      IndexReader reader = (IndexReader)e.getValue();      reader.getTermFreqVector(docNumber, field, mapper);    }  }  public boolean hasNorms(String field) throws IOException {    ensureOpen();    IndexReader reader = ((IndexReader)fieldToReader.get(field));    return reader==null ? false : reader.hasNorms(field);  }  public byte[] norms(String field) throws IOException {    ensureOpen();    IndexReader reader = ((IndexReader)fieldToReader.get(field));    return reader==null ? null : reader.norms(field);  }  public void norms(String field, byte[] result, int offset)    throws IOException {    ensureOpen();    IndexReader reader = ((IndexReader)fieldToReader.get(field));    if (reader!=null)      reader.norms(field, result, offset);  }  protected void doSetNorm(int n, String field, byte value)    throws CorruptIndexException, IOException {    IndexReader reader = ((IndexReader)fieldToReader.get(field));    if (reader!=null)      reader.doSetNorm(n, field, value);  }  public TermEnum terms() throws IOException {    ensureOpen();    return new ParallelTermEnum();  }  public TermEnum terms(Term term) throws IOException {    ensureOpen();    return new ParallelTermEnum(term);  }  public int docFreq(Term term) throws IOException {    ensureOpen();    IndexReader reader = ((IndexReader)fieldToReader.get(term.field()));    return reader==null ? 0 : reader.docFreq(term);  }  public TermDocs termDocs(Term term) throws IOException {    ensureOpen();    return new ParallelTermDocs(term);  }  public TermDocs termDocs() throws IOException {    ensureOpen();    return new ParallelTermDocs();  }  public TermPositions termPositions(Term term) throws IOException {    ensureOpen();    return new ParallelTermPositions(term);  }  public TermPositions termPositions() throws IOException {    ensureOpen();    return new ParallelTermPositions();  }    /**   * Checks recursively if all subreaders are up to date.    */  public boolean isCurrent() throws CorruptIndexException, IOException {    for (int i = 0; i < readers.size(); i++) {      if (!((IndexReader)readers.get(i)).isCurrent()) {        return false;      }    }        // all subreaders are up to date    return true;  }  /**   * Checks recursively if all subindexes are optimized    */  public boolean isOptimized() {    for (int i = 0; i < readers.size(); i++) {      if (!((IndexReader)readers.get(i)).isOptimized()) {        return false;      }    }        // all subindexes are optimized    return true;  }    /** Not implemented.   * @throws UnsupportedOperationException   */  public long getVersion() {    throw new UnsupportedOperationException("ParallelReader does not support this method.");  }  // for testing  IndexReader[] getSubReaders() {    return (IndexReader[]) readers.toArray(new IndexReader[readers.size()]);  }  protected void doCommit() throws IOException {    for (int i = 0; i < readers.size(); i++)      ((IndexReader)readers.get(i)).commit();  }  protected synchronized void doClose() throws IOException {    for (int i = 0; i < readers.size(); i++) {      if (((Boolean) decrefOnClose.get(i)).booleanValue()) {        ((IndexReader)readers.get(i)).decRef();      } else {        ((IndexReader)readers.get(i)).close();      }    }  }  public Collection getFieldNames (IndexReader.FieldOption fieldNames) {    ensureOpen();    Set fieldSet = new HashSet();    for (int i = 0; i < readers.size(); i++) {      IndexReader reader = ((IndexReader)readers.get(i));      Collection names = reader.getFieldNames(fieldNames);      fieldSet.addAll(names);    }    return fieldSet;  }  private class ParallelTermEnum extends TermEnum {    private String field;    private Iterator fieldIterator;    private TermEnum termEnum;    public ParallelTermEnum() throws IOException {      field = (String)fieldToReader.firstKey();      if (field != null)        termEnum = ((IndexReader)fieldToReader.get(field)).terms();    }    public ParallelTermEnum(Term term) throws IOException {      field = term.field();      IndexReader reader = ((IndexReader)fieldToReader.get(field));      if (reader!=null)        termEnum = reader.terms(term);    }    public boolean next() throws IOException {      if (termEnum==null)        return false;      // another term in this field?      if (termEnum.next() && termEnum.term().field()==field)        return true;                              // yes, keep going      termEnum.close();                           // close old termEnum      // find the next field with terms, if any      if (fieldIterator==null) {        fieldIterator = fieldToReader.tailMap(field).keySet().iterator();        fieldIterator.next();                     // Skip field to get next one      }      while (fieldIterator.hasNext()) {        field = (String) fieldIterator.next();        termEnum = ((IndexReader)fieldToReader.get(field)).terms(new Term(field));        Term term = termEnum.term();        if (term!=null && term.field()==field)          return true;        else          termEnum.close();      }       return false;                               // no more fields    }    public Term term() {      if (termEnum==null)        return null;      return termEnum.term();    }    public int docFreq() {      if (termEnum==null)        return 0;      return termEnum.docFreq();    }    public void close() throws IOException {      if (termEnum!=null)        termEnum.close();    }  }  // wrap a TermDocs in order to support seek(Term)  private class ParallelTermDocs implements TermDocs {    protected TermDocs termDocs;    public ParallelTermDocs() {}    public ParallelTermDocs(Term term) throws IOException { seek(term); }    public int doc() { return termDocs.doc(); }    public int freq() { return termDocs.freq(); }    public void seek(Term term) throws IOException {      IndexReader reader = ((IndexReader)fieldToReader.get(term.field()));      termDocs = reader!=null ? reader.termDocs(term) : null;    }    public void seek(TermEnum termEnum) throws IOException {      seek(termEnum.term());    }    public boolean next() throws IOException {      if (termDocs==null)        return false;      return termDocs.next();    }    public int read(final int[] docs, final int[] freqs) throws IOException {      if (termDocs==null)        return 0;      return termDocs.read(docs, freqs);    }    public boolean skipTo(int target) throws IOException {      if (termDocs==null)        return false;      return termDocs.skipTo(target);    }    public void close() throws IOException {      if (termDocs!=null)        termDocs.close();    }  }  private class ParallelTermPositions    extends ParallelTermDocs implements TermPositions {    public ParallelTermPositions() {}    public ParallelTermPositions(Term term) throws IOException { seek(term); }    public void seek(Term term) throws IOException {      IndexReader reader = ((IndexReader)fieldToReader.get(term.field()));      termDocs = reader!=null ? reader.termPositions(term) : null;    }    public int nextPosition() throws IOException {      // It is an error to call this if there is no next position, e.g. if termDocs==null      return ((TermPositions)termDocs).nextPosition();    }    public int getPayloadLength() {      return ((TermPositions)termDocs).getPayloadLength();    }    public byte[] getPayload(byte[] data, int offset) throws IOException {      return ((TermPositions)termDocs).getPayload(data, offset);    }    // TODO: Remove warning after API has been finalized    public boolean isPayloadAvailable() {      return ((TermPositions) termDocs).isPayloadAvailable();    }  }}