SegmentMerger(Directory dir,
    String name) 
{
    directory = dir;
    segment = name;
    checkAbort = new CheckAbort(null, null) {
      @Override
      public void work(double units) throws MergeAbortedException {
        // do nothing
      }
    };
}

This ctor used only by test code.

Parameters:

dir - The Directory to merge the other segments into

name - The name of the new segment

 SegmentMerger(IndexWriter writer,
    String name,
    OneMerge merge) 
{
    directory = writer.getDirectory();
    segment = name;
    if (merge != null) {
      checkAbort = new CheckAbort(merge, directory);
    } else {
      checkAbort = new CheckAbort(null, null) {
        @Override
        public void work(double units) throws MergeAbortedException {
          // do nothing
        }
      };
    }
    termIndexInterval = writer.getTermIndexInterval();
}

 final  void add(IndexReader reader) 
{
    readers.add(reader);
}

Add an IndexReader to the collection of readers that are to be merged

 final  void closeReaders() throws IOException 
{
    for (final IndexReader reader : readers) {
      reader.close();
    }
}

close all IndexReaders that have been added. Should not be called before merge().

 final List<String> createCompoundFile(String fileName) throws IOException 
{
    CompoundFileWriter cfsWriter =
      new CompoundFileWriter(directory, fileName, checkAbort);
    List< String > files =
      new ArrayList< String >(IndexFileNames.COMPOUND_EXTENSIONS.length + 1);    
    // Basic files
    for (int i = 0; i <  IndexFileNames.COMPOUND_EXTENSIONS.length; i++) {
      String ext = IndexFileNames.COMPOUND_EXTENSIONS[i];
      if (ext.equals(IndexFileNames.PROX_EXTENSION) && !hasProx())
        continue;
      if (mergeDocStores || (!ext.equals(IndexFileNames.FIELDS_EXTENSION) &&
                            !ext.equals(IndexFileNames.FIELDS_INDEX_EXTENSION)))
        files.add(segment + "." + ext);
    }
    // Fieldable norm files
    for (int i = 0; i <  fieldInfos.size(); i++) {
      FieldInfo fi = fieldInfos.fieldInfo(i);
      if (fi.isIndexed && !fi.omitNorms) {
        files.add(segment + "." + IndexFileNames.NORMS_EXTENSION);
        break;
      }
    }
    // Vector files
    if (fieldInfos.hasVectors() && mergeDocStores) {
      for (int i = 0; i <  IndexFileNames.VECTOR_EXTENSIONS.length; i++) {
        files.add(segment + "." + IndexFileNames.VECTOR_EXTENSIONS[i]);
      }
    }
    // Now merge all added files
    for (String file : files) {
      cfsWriter.addFile(file);
    }
    // Perform the merge
    cfsWriter.close();
    return files;
}

 int[] getDelCounts() 
{
    return delCounts;
}

 int[][] getDocMaps() 
{
    return docMaps;
}

 boolean hasProx() 
{
    return fieldInfos.hasProx();
}

 final int merge() throws CorruptIndexException, IOException 
{
    return merge(true);
}

Merges the readers specified by the #add method into the directory passed to the constructor

 final int merge(boolean mergeDocStores) throws CorruptIndexException, IOException 
{
    this.mergeDocStores = mergeDocStores;
    // NOTE: it's important to add calls to
    // checkAbort.work(...) if you make any changes to this
    // method that will spend alot of time.  The frequency
    // of this check impacts how long
    // IndexWriter.close(false) takes to actually stop the
    // threads.
    mergedDocs = mergeFields();
    mergeTerms();
    mergeNorms();
    if (mergeDocStores && fieldInfos.hasVectors())
      mergeVectors();
    return mergedDocs;
}

Merges the readers specified by the #add method into the directory passed to the constructor.

 final IndexReader segmentReader(int i) 
{
    return readers.get(i);
}