SegmentTermEnum(IndexInput i,
    FieldInfos fis,
    boolean isi) throws IOException, CorruptIndexException 
{
       
    input = i;
    fieldInfos = fis;
    isIndex = isi;
    maxSkipLevels = 1; // use single-level skip lists for formats  > -3 
    int firstInt = input.readInt();
    if (firstInt  >= 0) {
      // original-format file, without explicit format version number
      format = 0;
      size = firstInt;
      // back-compatible settings
      indexInterval = 128;
      skipInterval = Integer.MAX_VALUE; // switch off skipTo optimization
    } else {
      // we have a format version number
      format = firstInt;
      // check that it is a format we can understand
      if (format <  TermInfosWriter.FORMAT)
        throw new CorruptIndexException("Unknown format version:" + format);
      size = input.readLong();                    // read the size
      if(format == -1){
        if (!isIndex) {
          indexInterval = input.readInt();
          formatM1SkipInterval = input.readInt();
        }
        // switch off skipTo optimization for file format prior to 1.4rc2 in order to avoid a bug in 
        // skipTo implementation of these versions
        skipInterval = Integer.MAX_VALUE;
      } else {
        indexInterval = input.readInt();
        skipInterval = input.readInt();
        if (format == -3) {
          // this new format introduces multi-level skipping
          maxSkipLevels = input.readInt();
        }
      }
    }
}

 protected Object clone() 
{
    SegmentTermEnum clone = null;
    try {
      clone = (SegmentTermEnum) super.clone();
    } catch (CloneNotSupportedException e) {}
    clone.input = (IndexInput) input.clone();
    clone.termInfo = new TermInfo(termInfo);
    clone.termBuffer = (TermBuffer)termBuffer.clone();
    clone.prevBuffer = (TermBuffer)prevBuffer.clone();
    clone.scratch = null;
    return clone;
}

 public final  void close() throws IOException 
{
    input.close();
}

Closes the enumeration to further activity, freeing resources.

 public final int docFreq() 
{
    return termInfo.docFreq;
}

Returns the docFreq from the current TermInfo in the enumeration. Initially invalid, valid after next() called for the first time.

 final long freqPointer() 
{
    return termInfo.freqPointer;
}

 public final boolean next() throws IOException 
{
    if (position++  >= size - 1) {
      prevBuffer.set(termBuffer);
      termBuffer.reset();
      return false;
    }
    prevBuffer.set(termBuffer);
    termBuffer.read(input, fieldInfos);
    termInfo.docFreq = input.readVInt();	  // read doc freq
    termInfo.freqPointer += input.readVLong();	  // read freq pointer
    termInfo.proxPointer += input.readVLong();	  // read prox pointer
    if(format == -1){
    //  just read skipOffset in order to increment  file pointer; 
    // value is never used since skipTo is switched off
      if (!isIndex) {
        if (termInfo.docFreq  > formatM1SkipInterval) {
          termInfo.skipOffset = input.readVInt(); 
        }
      }
    }
    else{
      if (termInfo.docFreq  >= skipInterval) 
        termInfo.skipOffset = input.readVInt();
    }
    if (isIndex)
      indexPointer += input.readVLong();	  // read index pointer
    return true;
}

Increments the enumeration to the next element. True if one exists.

 final Term prev() 
{
    return prevBuffer.toTerm();
}

Returns the previous Term enumerated. Initially null.

 final long proxPointer() 
{
    return termInfo.proxPointer;
}

 final  void scanTo(Term term) throws IOException 
{
    if (scratch == null)
      scratch = new TermBuffer();
    scratch.set(term);
    while (scratch.compareTo(termBuffer)  > 0 && next()) {}
}

Optimized scan, without allocating new terms.

 final  void seek(long pointer,
    int p,
    Term t,
    TermInfo ti) throws IOException 
{
    input.seek(pointer);
    position = p;
    termBuffer.set(t);
    prevBuffer.reset();
    termInfo.set(ti);
}

 public final Term term() 
{
    return termBuffer.toTerm();
}

Returns the current Term in the enumeration. Initially invalid, valid after next() called for the first time.

 final TermInfo termInfo() 
{
    return new TermInfo(termInfo);
}

Returns the current TermInfo in the enumeration. Initially invalid, valid after next() called for the first time.

 final  void termInfo(TermInfo ti) 
{
    ti.set(termInfo);
}

Sets the argument to the current TermInfo in the enumeration. Initially invalid, valid after next() called for the first time.