public MultiReader(IndexReader subReaders) 
{
    initialize(subReaders, true);
}

Construct a MultiReader aggregating the named set of (sub)readers. Directory locking for delete, undeleteAll, and setNorm operations is left to the subreaders.

Note that all subreaders are closed if this Multireader is closed.

Parameters:

subReaders - set of (sub)readers

Throws:

IOException -

 public MultiReader(IndexReader[] subReaders,
    boolean closeSubReaders) 
{
    initialize(subReaders, closeSubReaders);
}

Construct a MultiReader aggregating the named set of (sub)readers. Directory locking for delete, undeleteAll, and setNorm operations is left to the subreaders.

Parameters:

closeSubReaders - indicates whether the subreaders should be closed when this MultiReader is closed

subReaders - set of (sub)readers

Throws:

IOException -

 public synchronized Object clone() 
{
    try {
      return doReopen(true);
    } catch (Exception ex) {
      throw new RuntimeException(ex);
    }
}

Clones the subreaders. (see IndexReader#clone() ).


If subreaders are shared, then the reference count of those readers is increased to ensure that the subreaders remain open until the last referring reader is closed.

 protected synchronized  void doClose() throws IOException 
{
    for (int i = 0; i <  subReaders.length; i++) {
      if (decrefOnClose[i]) {
        subReaders[i].decRef();
      } else {
        subReaders[i].close();
      }
    }
}

 protected  void doCommit(Map<String, String> commitUserData) throws IOException 
{
    for (int i = 0; i <  subReaders.length; i++)
      subReaders[i].commit(commitUserData);
}

 protected  void doDelete(int n) throws CorruptIndexException, IOException 
{
    numDocs = -1;                             // invalidate cache
    int i = readerIndex(n);                   // find segment num
    subReaders[i].deleteDocument(n - starts[i]);      // dispatch to segment reader
    hasDeletions = true;
}

 protected IndexReader doReopen(boolean doClone) throws CorruptIndexException, IOException 
{
    ensureOpen();
    boolean reopened = false;
    IndexReader[] newSubReaders = new IndexReader[subReaders.length];
    boolean success = false;
    try {
      for (int i = 0; i <  subReaders.length; i++) {
        if (doClone)
          newSubReaders[i] = (IndexReader) subReaders[i].clone();
        else
          newSubReaders[i] = subReaders[i].reopen();
        // if at least one of the subreaders was updated we remember that
        // and return a new MultiReader
        if (newSubReaders[i] != subReaders[i]) {
          reopened = true;
        }
      }
      success = true;
    } finally {
      if (!success && reopened) {
        for (int i = 0; i <  newSubReaders.length; i++) {
          if (newSubReaders[i] != subReaders[i]) {
            try {
              newSubReaders[i].close();
            } catch (IOException ignore) {
              // keep going - we want to clean up as much as possible
            }
          }
        }
      }
    }
    if (reopened) {
      boolean[] newDecrefOnClose = new boolean[subReaders.length];
      for (int i = 0; i <  subReaders.length; i++) {
        if (newSubReaders[i] == subReaders[i]) {
          newSubReaders[i].incRef();
          newDecrefOnClose[i] = true;
        }
      }
      MultiReader mr = new MultiReader(newSubReaders);
      mr.decrefOnClose = newDecrefOnClose;
      return mr;
    } else {
      return this;
    }
}

If clone is true then we clone each of the subreaders

 protected  void doSetNorm(int n,
    String field,
    byte value) throws CorruptIndexException, IOException 
{
    synchronized (normsCache) {
      normsCache.remove(field);                         // clear cache
    }
    int i = readerIndex(n);                           // find segment num
    subReaders[i].setNorm(n-starts[i], field, value); // dispatch
}

 protected  void doUndeleteAll() throws CorruptIndexException, IOException 
{
    for (int i = 0; i <  subReaders.length; i++)
      subReaders[i].undeleteAll();
    hasDeletions = false;
    numDocs = -1;                                 // invalidate cache
}

 public int docFreq(Term t) throws IOException 
{
    ensureOpen();
    int total = 0;          // sum freqs in segments
    for (int i = 0; i <  subReaders.length; i++)
      total += subReaders[i].docFreq(t);
    return total;
}

 public Document document(int n,
    FieldSelector fieldSelector) throws CorruptIndexException, IOException 
{
    ensureOpen();
    int i = readerIndex(n);                          // find segment num
    return subReaders[i].document(n - starts[i], fieldSelector);    // dispatch to segment reader
}

 public Collection<String> getFieldNames(FieldOption fieldNames) 
{
    ensureOpen();
    return DirectoryReader.getFieldNames(fieldNames, this.subReaders);
}

 public IndexReader[] getSequentialSubReaders() 
{
    return subReaders;
}

 public TermFreqVector getTermFreqVector(int n,
    String field) throws IOException 
{
    ensureOpen();
    int i = readerIndex(n);        // find segment num
    return subReaders[i].getTermFreqVector(n - starts[i], field);
}

 public  void getTermFreqVector(int docNumber,
    TermVectorMapper mapper) throws IOException 
{
    ensureOpen();
    int i = readerIndex(docNumber);        // find segment num
    subReaders[i].getTermFreqVector(docNumber - starts[i], mapper);
}

 public  void getTermFreqVector(int docNumber,
    String field,
    TermVectorMapper mapper) throws IOException 
{
    ensureOpen();
    int i = readerIndex(docNumber);        // find segment num
    subReaders[i].getTermFreqVector(docNumber - starts[i], field, mapper);
}

 public TermFreqVector[] getTermFreqVectors(int n) throws IOException 
{
    ensureOpen();
    int i = readerIndex(n);        // find segment num
    return subReaders[i].getTermFreqVectors(n - starts[i]); // dispatch to segment
}

 public long getVersion() 
{
    throw new UnsupportedOperationException("MultiReader does not support this method.");
}

Not implemented.

 public boolean hasDeletions() 
{
    // Don't call ensureOpen() here (it could affect performance)
    return hasDeletions;
}

 public boolean hasNorms(String field) throws IOException 
{
    ensureOpen();
    for (int i = 0; i <  subReaders.length; i++) {
      if (subReaders[i].hasNorms(field)) return true;
    }
    return false;
}

 public boolean isCurrent() throws CorruptIndexException, IOException 
{
    for (int i = 0; i <  subReaders.length; i++) {
      if (!subReaders[i].isCurrent()) {
        return false;
      }
    }
    // all subreaders are up to date
    return true;
}

Checks recursively if all subreaders are up to date.

 public boolean isDeleted(int n) 
{
    // Don't call ensureOpen() here (it could affect performance)
    int i = readerIndex(n);                           // find segment num
    return subReaders[i].isDeleted(n - starts[i]);    // dispatch to segment reader
}

 public boolean isOptimized() 
{
    return false;
}

 public int maxDoc() 
{
    // Don't call ensureOpen() here (it could affect performance)
    return maxDoc;
}

 public synchronized byte[] norms(String field) throws IOException 
{
    ensureOpen();
    byte[] bytes = normsCache.get(field);
    if (bytes != null)
      return bytes;          // cache hit
    if (!hasNorms(field))
      return null;
    bytes = new byte[maxDoc()];
    for (int i = 0; i <  subReaders.length; i++)
      subReaders[i].norms(field, bytes, starts[i]);
    normsCache.put(field, bytes);      // update cache
    return bytes;
}

 public synchronized  void norms(String field,
    byte[] result,
    int offset) throws IOException 
{
    ensureOpen();
    byte[] bytes = normsCache.get(field);
    for (int i = 0; i <  subReaders.length; i++)      // read from segments
      subReaders[i].norms(field, result, offset + starts[i]);
    if (bytes==null && !hasNorms(field)) {
      Arrays.fill(result, offset, result.length, DefaultSimilarity.encodeNorm(1.0f));
    } else if (bytes != null) {                         // cache hit
      System.arraycopy(bytes, 0, result, offset, maxDoc());
    } else {
      for (int i = 0; i <  subReaders.length; i++) {     // read from segments
        subReaders[i].norms(field, result, offset + starts[i]);
      }
    }
}

 public synchronized int numDocs() 
{
    // Don't call ensureOpen() here (it could affect performance)
    if (numDocs == -1) {        // check cache
      int n = 0;                // cache miss--recompute
      for (int i = 0; i <  subReaders.length; i++)
        n += subReaders[i].numDocs();      // sum from readers
      numDocs = n;
    }
    return numDocs;
}

 public synchronized IndexReader reopen() throws CorruptIndexException, IOException 
{
    return doReopen(false);
}

Tries to reopen the subreaders.
If one or more subreaders could be re-opened (i. e. subReader.reopen() returned a new instance != subReader), then a new MultiReader instance is returned, otherwise this instance is returned.

A re-opened instance might share one or more subreaders with the old instance. Index modification operations result in undefined behavior when performed before the old instance is closed. (see IndexReader#reopen() ).

If subreaders are shared, then the reference count of those readers is increased to ensure that the subreaders remain open until the last referring reader is closed.

 public TermDocs termDocs() throws IOException 
{
    ensureOpen();
    return new MultiTermDocs(this, subReaders, starts);
}

 public TermPositions termPositions() throws IOException 
{
    ensureOpen();
    return new MultiTermPositions(this, subReaders, starts);
}

 public TermEnum terms() throws IOException 
{
    ensureOpen();
    return new MultiTermEnum(this, subReaders, starts, null);
}

 public TermEnum terms(Term term) throws IOException 
{
    ensureOpen();
    return new MultiTermEnum(this, subReaders, starts, term);
}