protected  void commitChanges() throws IOException 
{
    if (deletedDocsDirty) {               // re-write deleted
      si.advanceDelGen();
      // We can write directly to the actual name (vs to a
      // .tmp & renaming it) because the file is not live
      // until segments file is written:
      deletedDocs.write(directory(), si.getDelFileName());
    }
    if (undeleteAll && si.hasDeletions()) {
      si.clearDelGen();
    }
    if (normsDirty) {               // re-write norms
      si.setNumFields(fieldInfos.size());
      Iterator it = norms.values().iterator();
      while (it.hasNext()) {
        Norm norm = (Norm) it.next();
        if (norm.dirty) {
          norm.reWrite(si);
        }
      }
    }
    deletedDocsDirty = false;
    normsDirty = false;
    undeleteAll = false;
}

 static byte[] createFakeNorms(int size) 
{
    byte[] ones = new byte[size];
    Arrays.fill(ones, DefaultSimilarity.encodeNorm(1.0f));
    return ones;
}

 protected synchronized  void decRef() throws IOException 
{
    super.decRef();
    Iterator it = norms.values().iterator();
    while (it.hasNext()) {
      Norm norm = (Norm) it.next();
      norm.decRef();
    }
}

 protected  void doClose() throws IOException 
{
    boolean hasReferencedReader = (referencedSegmentReader != null);
    if (hasReferencedReader) {
      referencedSegmentReader.decRefReaderNotNorms();
      referencedSegmentReader = null;
    }
    deletedDocs = null;
    // close the single norms stream
    if (singleNormStream != null) {
      // we can close this stream, even if the norms
      // are shared, because every reader has it's own 
      // singleNormStream
      singleNormStream.close();
      singleNormStream = null;
    }
    // re-opened SegmentReaders have their own instance of FieldsReader
    if (fieldsReader != null) {
      fieldsReader.close();
    }
    if (!hasReferencedReader) { 
      // close everything, nothing is shared anymore with other readers
      if (tis != null) {
        tis.close();
      }
      if (freqStream != null)
        freqStream.close();
      if (proxStream != null)
        proxStream.close();
      if (termVectorsReaderOrig != null)
        termVectorsReaderOrig.close();
      if (cfsReader != null)
        cfsReader.close();
      if (storeCFSReader != null)
        storeCFSReader.close();
      // maybe close directory
      super.doClose();
    }
}

 protected  void doDelete(int docNum) 
{
    if (deletedDocs == null)
      deletedDocs = new BitVector(maxDoc());
    deletedDocsDirty = true;
    undeleteAll = false;
    deletedDocs.set(docNum);
}

 protected synchronized DirectoryIndexReader doReopen(SegmentInfos infos) throws IOException, CorruptIndexException 
{
    DirectoryIndexReader newReader;
    if (infos.size() == 1) {
      SegmentInfo si = infos.info(0);
      if (segment.equals(si.name) && si.getUseCompoundFile() == SegmentReader.this.si.getUseCompoundFile()) {
        newReader = reopenSegment(si);
      } else { 
        // segment not referenced anymore, reopen not possible
        // or segment format changed
        newReader = SegmentReader.get(infos, infos.info(0), false);
      }
    } else {
      return new MultiSegmentReader(directory, infos, closeDirectory, new SegmentReader[] {this}, null, null);
    }
    return newReader;
}

 protected  void doSetNorm(int doc,
    String field,
    byte value) throws IOException 
{
    Norm norm = (Norm) norms.get(field);
    if (norm == null)                             // not an indexed field
      return;
    norm.dirty = true;                            // mark it dirty
    normsDirty = true;
    norms(field)[doc] = value;                    // set the value
}

 protected  void doUndeleteAll() 
{
      deletedDocs = null;
      deletedDocsDirty = false;
      undeleteAll = true;
}

 public int docFreq(Term t) throws IOException 
{
    ensureOpen();
    TermInfo ti = tis.get(t);
    if (ti != null)
      return ti.docFreq;
    else
      return 0;
}

 public synchronized Document document(int n,
    FieldSelector fieldSelector) throws IOException, CorruptIndexException 
{
    ensureOpen();
    if (isDeleted(n))
      throw new IllegalArgumentException
              ("attempt to access a deleted document");
    return fieldsReader.doc(n, fieldSelector);
}

 FieldInfos fieldInfos() 
{
    return fieldInfos;
}

Returns the field infos of this segment

 Vector files() throws IOException 
{
    return new Vector(si.files());
}

 public static SegmentReader get(SegmentInfo si) throws IOException, CorruptIndexException 
{
   
    try {
      String name =
        System.getProperty("org.apache.lucene.SegmentReader.class",
                           SegmentReader.class.getName());
      IMPL = Class.forName(name);
    } catch (ClassNotFoundException e) {
      throw new RuntimeException("cannot load SegmentReader class: " + e, e);
    } catch (SecurityException se) {
      try {
        IMPL = Class.forName(SegmentReader.class.getName());
      } catch (ClassNotFoundException e) {
        throw new RuntimeException("cannot load default SegmentReader class: " + e, e);
      }
    }
    return get(si.dir, si, null, false, false, BufferedIndexInput.BUFFER_SIZE, true);
}

 static SegmentReader get(SegmentInfo si,
    boolean doOpenStores) throws IOException, CorruptIndexException 
{
    return get(si.dir, si, null, false, false, BufferedIndexInput.BUFFER_SIZE, doOpenStores);
}

 public static SegmentReader get(SegmentInfo si,
    int readBufferSize) throws IOException, CorruptIndexException 
{
    return get(si.dir, si, null, false, false, readBufferSize, true);
}

 static SegmentReader get(SegmentInfo si,
    int readBufferSize,
    boolean doOpenStores) throws IOException, CorruptIndexException 
{
    return get(si.dir, si, null, false, false, readBufferSize, doOpenStores);
}

 public static SegmentReader get(SegmentInfos sis,
    SegmentInfo si,
    boolean closeDir) throws IOException, CorruptIndexException 
{
    return get(si.dir, si, sis, closeDir, true, BufferedIndexInput.BUFFER_SIZE, true);
}

 public static SegmentReader get(Directory dir,
    SegmentInfo si,
    SegmentInfos sis,
    boolean closeDir,
    boolean ownDir,
    int readBufferSize) throws IOException, CorruptIndexException 
{
    return get(dir, si, sis, closeDir, ownDir, readBufferSize, true);
}

 public static SegmentReader get(Directory dir,
    SegmentInfo si,
    SegmentInfos sis,
    boolean closeDir,
    boolean ownDir,
    int readBufferSize,
    boolean doOpenStores) throws IOException, CorruptIndexException 
{
    SegmentReader instance;
    try {
      instance = (SegmentReader)IMPL.newInstance();
    } catch (Exception e) {
      throw new RuntimeException("cannot load SegmentReader class: " + e, e);
    }
    instance.init(dir, sis, closeDir);
    instance.initialize(si, readBufferSize, doOpenStores);
    return instance;
}

 FieldInfos getFieldInfos() 
{
    return fieldInfos;
}

 public Collection getFieldNames(IndexReader.FieldOption fieldOption) 
{
    ensureOpen();
    Set fieldSet = new HashSet();
    for (int i = 0; i <  fieldInfos.size(); i++) {
      FieldInfo fi = fieldInfos.fieldInfo(i);
      if (fieldOption == IndexReader.FieldOption.ALL) {
        fieldSet.add(fi.name);
      }
      else if (!fi.isIndexed && fieldOption == IndexReader.FieldOption.UNINDEXED) {
        fieldSet.add(fi.name);
      }
      else if (fi.storePayloads && fieldOption == IndexReader.FieldOption.STORES_PAYLOADS) {
        fieldSet.add(fi.name);
      }
      else if (fi.isIndexed && fieldOption == IndexReader.FieldOption.INDEXED) {
        fieldSet.add(fi.name);
      }
      else if (fi.isIndexed && fi.storeTermVector == false && fieldOption == IndexReader.FieldOption.INDEXED_NO_TERMVECTOR) {
        fieldSet.add(fi.name);
      }
      else if (fi.storeTermVector == true &&
               fi.storePositionWithTermVector == false &&
               fi.storeOffsetWithTermVector == false &&
               fieldOption == IndexReader.FieldOption.TERMVECTOR) {
        fieldSet.add(fi.name);
      }
      else if (fi.isIndexed && fi.storeTermVector && fieldOption == IndexReader.FieldOption.INDEXED_WITH_TERMVECTOR) {
        fieldSet.add(fi.name);
      }
      else if (fi.storePositionWithTermVector && fi.storeOffsetWithTermVector == false && fieldOption == IndexReader.FieldOption.TERMVECTOR_WITH_POSITION) {
        fieldSet.add(fi.name);
      }
      else if (fi.storeOffsetWithTermVector && fi.storePositionWithTermVector == false && fieldOption == IndexReader.FieldOption.TERMVECTOR_WITH_OFFSET) {
        fieldSet.add(fi.name);
      }
      else if ((fi.storeOffsetWithTermVector && fi.storePositionWithTermVector) &&
                fieldOption == IndexReader.FieldOption.TERMVECTOR_WITH_POSITION_OFFSET) {
        fieldSet.add(fi.name);
      }
    }
    return fieldSet;
}

 FieldsReader getFieldsReader() 
{
    return fieldsReader;
}

 protected synchronized byte[] getNorms(String field) throws IOException 
{
    Norm norm = (Norm) norms.get(field);
    if (norm == null) return null;  // not indexed, or norms not stored
    synchronized(norm) {
      if (norm.bytes == null) {                     // value not yet read
        byte[] bytes = new byte[maxDoc()];
        norms(field, bytes, 0);
        norm.bytes = bytes;                         // cache it
        // it's OK to close the underlying IndexInput as we have cached the
        // norms and will never read them again.
        norm.close();
      }
      return norm.bytes;
    }
}

 SegmentInfo getSegmentInfo() 
{
    return si;
}

Return the SegmentInfo of the segment this reader is reading.

 String getSegmentName() 
{
    return segment;
}

Return the name of the segment this reader is reading.

 public TermFreqVector getTermFreqVector(int docNumber,
    String field) throws IOException 
{
    // Check if this field is invalid or has no stored term vector
    ensureOpen();
    FieldInfo fi = fieldInfos.fieldInfo(field);
    if (fi == null || !fi.storeTermVector || termVectorsReaderOrig == null) 
      return null;
    TermVectorsReader termVectorsReader = getTermVectorsReader();
    if (termVectorsReader == null)
      return null;
    return termVectorsReader.get(docNumber, field);
}

Return a term frequency vector for the specified document and field. The vector returned contains term numbers and frequencies for all terms in the specified field of this document, if the field had storeTermVector flag set. If the flag was not set, the method returns null.

 public  void getTermFreqVector(int docNumber,
    TermVectorMapper mapper) throws IOException 
{
    ensureOpen();
    if (termVectorsReaderOrig == null)
      return;
    TermVectorsReader termVectorsReader = getTermVectorsReader();
    if (termVectorsReader == null)
      return;
    termVectorsReader.get(docNumber, mapper);
}

 public  void getTermFreqVector(int docNumber,
    String field,
    TermVectorMapper mapper) throws IOException 
{
    ensureOpen();
    FieldInfo fi = fieldInfos.fieldInfo(field);
    if (fi == null || !fi.storeTermVector || termVectorsReaderOrig == null)
      return;
    TermVectorsReader termVectorsReader = getTermVectorsReader();
    if (termVectorsReader == null)
    {
      return;
    }
    termVectorsReader.get(docNumber, field, mapper);
}

 public TermFreqVector[] getTermFreqVectors(int docNumber) throws IOException 
{
    ensureOpen();
    if (termVectorsReaderOrig == null)
      return null;
    TermVectorsReader termVectorsReader = getTermVectorsReader();
    if (termVectorsReader == null)
      return null;
    return termVectorsReader.get(docNumber);
}

Return an array of term frequency vectors for the specified document. The array contains a vector for each vectorized field in the document. Each vector vector contains term numbers and frequencies for all terms in a given vectorized field. If no such fields existed, the method returns null.

 public int getTermInfosIndexDivisor() 
{
    return tis.getIndexDivisor();
}

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

 static boolean hasDeletions(SegmentInfo si) throws IOException 
{
    // Don't call ensureOpen() here (it could affect performance)
    return si.hasDeletions();
}

 public synchronized boolean hasNorms(String field) 
{
    ensureOpen();
    return norms.containsKey(field);
}

 static boolean hasSeparateNorms(SegmentInfo si) throws IOException 
{
    return si.hasSeparateNorms();
}

 protected synchronized  void incRef() 
{
    super.incRef();
    Iterator it = norms.values().iterator();
    while (it.hasNext()) {
      Norm norm = (Norm) it.next();
      norm.incRef();
    }
}

Increments the RC of this reader, as well as of all norms this reader is using

 public synchronized boolean isDeleted(int n) 
{
    return (deletedDocs != null && deletedDocs.get(n));
}

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

 public synchronized byte[] norms(String field) throws IOException 
{
    ensureOpen();
    byte[] bytes = getNorms(field);
    if (bytes==null) bytes=fakeNorms();
    return bytes;
}

 public synchronized  void norms(String field,
    byte[] bytes,
    int offset) throws IOException 
{
    ensureOpen();
    Norm norm = (Norm) norms.get(field);
    if (norm == null) {
      System.arraycopy(fakeNorms(), 0, bytes, offset, maxDoc());
      return;
    }
    synchronized(norm) {
      if (norm.bytes != null) {                     // can copy from cache
        System.arraycopy(norm.bytes, 0, bytes, offset, maxDoc());
        return;
      }
    // Read from disk.  norm.in may be shared across  multiple norms and
    // should only be used in a synchronized context.
      IndexInput normStream;
      if (norm.useSingleNormStream) {
        normStream = singleNormStream;
      } else {
        normStream = norm.in;
      }
      normStream.seek(norm.normSeek);
      normStream.readBytes(bytes, offset, maxDoc());
    }
}

Read norms into a pre-allocated array.

 boolean normsClosed() 
{
    if (singleNormStream != null) {
      return false;
    }
    Iterator it = norms.values().iterator();
    while (it.hasNext()) {
      Norm norm = (Norm) it.next();
      if (norm.refCount  > 0) {
        return false;
      }
    }
    return true;
}

 boolean normsClosed(String field) 
{
      Norm norm = (Norm) norms.get(field);
      return norm.refCount == 0;
}

 public int numDocs() 
{
    // Don't call ensureOpen() here (it could affect performance)
    int n = maxDoc();
    if (deletedDocs != null)
      n -= deletedDocs.count();
    return n;
}

 synchronized SegmentReader reopenSegment(SegmentInfo si) throws IOException, CorruptIndexException 
{
    boolean deletionsUpToDate = (this.si.hasDeletions() == si.hasDeletions()) 
                                  && (!si.hasDeletions() || this.si.getDelFileName().equals(si.getDelFileName()));
    boolean normsUpToDate = true;
    boolean[] fieldNormsChanged = new boolean[fieldInfos.size()];
    if (normsUpToDate) {
      for (int i = 0; i <  fieldInfos.size(); i++) {
        if (!this.si.getNormFileName(i).equals(si.getNormFileName(i))) {
          normsUpToDate = false;
          fieldNormsChanged[i] = true;
        }
      }
    }
    if (normsUpToDate && deletionsUpToDate) {
      return this;
    }    
      // clone reader
    SegmentReader clone = new SegmentReader();
    boolean success = false;
    try {
      clone.directory = directory;
      clone.si = si;
      clone.segment = segment;
      clone.readBufferSize = readBufferSize;
      clone.cfsReader = cfsReader;
      clone.storeCFSReader = storeCFSReader;
      clone.fieldInfos = fieldInfos;
      clone.tis = tis;
      clone.freqStream = freqStream;
      clone.proxStream = proxStream;
      clone.termVectorsReaderOrig = termVectorsReaderOrig;
      // we have to open a new FieldsReader, because it is not thread-safe
      // and can thus not be shared among multiple SegmentReaders
      // TODO: Change this in case FieldsReader becomes thread-safe in the future
      final String fieldsSegment;
      Directory storeDir = directory();
      if (si.getDocStoreOffset() != -1) {
        fieldsSegment = si.getDocStoreSegment();
        if (storeCFSReader != null) {
          storeDir = storeCFSReader;
        }
      } else {
        fieldsSegment = segment;
        if (cfsReader != null) {
          storeDir = cfsReader;
        }
      }
      if (fieldsReader != null) {
        clone.fieldsReader = new FieldsReader(storeDir, fieldsSegment, fieldInfos, readBufferSize,
                                        si.getDocStoreOffset(), si.docCount);
      }
      if (!deletionsUpToDate) {
        // load deleted docs
        clone.deletedDocs = null;
        clone.loadDeletedDocs();
      } else {
        clone.deletedDocs = this.deletedDocs;
      }
      clone.norms = new HashMap();
      if (!normsUpToDate) {
        // load norms
        for (int i = 0; i <  fieldNormsChanged.length; i++) {
          // copy unchanged norms to the cloned reader and incRef those norms
          if (!fieldNormsChanged[i]) {
            String curField = fieldInfos.fieldInfo(i).name;
            Norm norm = (Norm) this.norms.get(curField);
            norm.incRef();
            clone.norms.put(curField, norm);
          }
        }
        clone.openNorms(si.getUseCompoundFile() ? cfsReader : directory(), readBufferSize);
      } else {
        Iterator it = norms.keySet().iterator();
        while (it.hasNext()) {
          String field = (String) it.next();
          Norm norm = (Norm) norms.get(field);
          norm.incRef();
          clone.norms.put(field, norm);
        }
      }
      if (clone.singleNormStream == null) {
        for (int i = 0; i <  fieldInfos.size(); i++) {
          FieldInfo fi = fieldInfos.fieldInfo(i);
          if (fi.isIndexed && !fi.omitNorms) {
            Directory d = si.getUseCompoundFile() ? cfsReader : directory();
            String fileName = si.getNormFileName(fi.number);
            if (si.hasSeparateNorms(fi.number)) {
              continue;
            }  
            if (fileName.endsWith("." + IndexFileNames.NORMS_EXTENSION)) {
              clone.singleNormStream = d.openInput(fileName, readBufferSize);    
              break;
            }
          }
        }  
      }    
      success = true;
    } finally {
      if (this.referencedSegmentReader != null) {
        // this reader shares resources with another SegmentReader,
        // so we increment the other readers refCount. We don't
        // increment the refCount of the norms because we did
        // that already for the shared norms
        clone.referencedSegmentReader = this.referencedSegmentReader;
        referencedSegmentReader.incRefReaderNotNorms();
      } else {
        // this reader wasn't reopened, so we increment this
        // readers refCount
        clone.referencedSegmentReader = this;
        incRefReaderNotNorms();
      }
      if (!success) {
        // An exception occured during reopen, we have to decRef the norms
        // that we incRef'ed already and close singleNormsStream and FieldsReader
        clone.decRef();
      }
    }
    return clone;
}

  void rollbackCommit() 
{
    super.rollbackCommit();
    deletedDocsDirty = rollbackDeletedDocsDirty;
    normsDirty = rollbackNormsDirty;
    undeleteAll = rollbackUndeleteAll;
    Iterator it = norms.values().iterator();
    while (it.hasNext()) {
      Norm norm = (Norm) it.next();
      norm.dirty = norm.rollbackDirty;
    }
}

  void setSegmentInfo(SegmentInfo info) 
{
    si = info;
}

 public  void setTermInfosIndexDivisor(int indexDivisor) throws IllegalStateException 
{
    tis.setIndexDivisor(indexDivisor);
}

  void startCommit() 
{
    super.startCommit();
    rollbackDeletedDocsDirty = deletedDocsDirty;
    rollbackNormsDirty = normsDirty;
    rollbackUndeleteAll = undeleteAll;
    Iterator it = norms.values().iterator();
    while (it.hasNext()) {
      Norm norm = (Norm) it.next();
      norm.rollbackDirty = norm.dirty;
    }
}

 public TermDocs termDocs() throws IOException 
{
    ensureOpen();
    return new SegmentTermDocs(this);
}

 public TermPositions termPositions() throws IOException 
{
    ensureOpen();
    return new SegmentTermPositions(this);
}

 public TermEnum terms() 
{
    ensureOpen();
    return tis.terms();
}

 public TermEnum terms(Term t) throws IOException 
{
    ensureOpen();
    return tis.terms(t);
}

 static boolean usesCompoundFile(SegmentInfo si) throws IOException 
{
    return si.getUseCompoundFile();
}