TermInfosReader(Directory dir,
    String seg,
    FieldInfos fis) throws IOException, CorruptIndexException 
{
       
    this(dir, seg, fis, BufferedIndexInput.BUFFER_SIZE);
}

 TermInfosReader(Directory dir,
    String seg,
    FieldInfos fis,
    int readBufferSize) throws IOException, CorruptIndexException 
{
    boolean success = false;
    try {
      directory = dir;
      segment = seg;
      fieldInfos = fis;
      origEnum = new SegmentTermEnum(directory.openInput(segment + ".tis",
          readBufferSize), fieldInfos, false);
      size = origEnum.size;
      totalIndexInterval = origEnum.indexInterval;
      indexEnum = new SegmentTermEnum(directory.openInput(segment + ".tii",
          readBufferSize), fieldInfos, true);
      success = true;
    } finally {
      // With lock-less commits, it's entirely possible (and
      // fine) to hit a FileNotFound exception above. In
      // this case, we want to explicitly close any subset
      // of things that were opened so that we don't have to
      // wait for a GC to do so.
      if (!success) {
        close();
      }
    }
}

 final  void close() throws IOException 
{
    if (origEnum != null)
      origEnum.close();
    if (indexEnum != null)
      indexEnum.close();
    enumerators.set(null);
}

 TermInfo get(Term term) throws IOException 
{
    if (size == 0) return null;
    ensureIndexIsRead();
    // optimize sequential access: first try scanning cached enum w/o seeking
    SegmentTermEnum enumerator = getEnum();
    if (enumerator.term() != null                 // term is at or past current
	&& ((enumerator.prev() != null && term.compareTo(enumerator.prev()) > 0)
	    || term.compareTo(enumerator.term())  >= 0)) {
      int enumOffset = (int)(enumerator.position/totalIndexInterval)+1;
      if (indexTerms.length == enumOffset	  // but before end of block
	  || term.compareTo(indexTerms[enumOffset]) <  0)
	return scanEnum(term);			  // no need to seek
    }
    // random-access: must seek
    seekEnum(getIndexOffset(term));
    return scanEnum(term);
}

Returns the TermInfo for a Term in the set, or null.

 final Term get(int position) throws IOException 
{
    if (size == 0) return null;
    SegmentTermEnum enumerator = getEnum();
    if (enumerator != null && enumerator.term() != null &&
        position  >= enumerator.position &&
	position <  (enumerator.position + totalIndexInterval))
      return scanEnum(position);		  // can avoid seek
    seekEnum(position/totalIndexInterval); // must seek
    return scanEnum(position);
}

Returns the nth term in the set.

 public int getIndexDivisor() 
{
    return indexDivisor;
}

Returns the indexDivisor.

 public int getMaxSkipLevels() 
{
    return origEnum.maxSkipLevels;
}

 final long getPosition(Term term) throws IOException 
{
    if (size == 0) return -1;
    ensureIndexIsRead();
    int indexOffset = getIndexOffset(term);
    seekEnum(indexOffset);
    SegmentTermEnum enumerator = getEnum();
    while(term.compareTo(enumerator.term())  > 0 && enumerator.next()) {}
    if (term.compareTo(enumerator.term()) == 0)
      return enumerator.position;
    else
      return -1;
}

Returns the position of a Term in the set or -1.

 public int getSkipInterval() 
{
    return origEnum.skipInterval;
}

 public  void setIndexDivisor(int indexDivisor) throws IllegalStateException 
{
    if (indexDivisor <  1)
      throw new IllegalArgumentException("indexDivisor must be  > 0: got " + indexDivisor);
    if (indexTerms != null)
      throw new IllegalStateException("index terms are already loaded");
    this.indexDivisor = indexDivisor;
    totalIndexInterval = origEnum.indexInterval * indexDivisor;
}

Sets the indexDivisor, which subsamples the number of indexed terms loaded into memory. This has a similar effect as IndexWriter#setTermIndexInterval except that setting must be done at indexing time while this setting can be set per reader. When set to N, then one in every N*termIndexInterval terms in the index is loaded into memory. By setting this to a value > 1 you can reduce memory usage, at the expense of higher latency when loading a TermInfo. The default value is 1.

NOTE: you must call this before the term index is loaded. If the index is already loaded, an IllegalStateException is thrown. + @throws IllegalStateException if the term index has already been loaded into memory.

 final long size() 
{
    return size;
}

Returns the number of term/value pairs in the set.

 public SegmentTermEnum terms() 
{
    return (SegmentTermEnum)origEnum.clone();
}

Returns an enumeration of all the Terms and TermInfos in the set.

 public SegmentTermEnum terms(Term term) throws IOException 
{
    get(term);
    return (SegmentTermEnum)getEnum().clone();
}

Returns an enumeration of terms starting at or after the named term.