FieldsReader(Directory d,
    String segment,
    FieldInfos fn) throws IOException 
{
          
    this(d, segment, fn, BufferedIndexInput.BUFFER_SIZE, -1, 0);
}

 FieldsReader(Directory d,
    String segment,
    FieldInfos fn,
    int readBufferSize) throws IOException 
{
    this(d, segment, fn, readBufferSize, -1, 0);
}

 FieldsReader(Directory d,
    String segment,
    FieldInfos fn,
    int readBufferSize,
    int docStoreOffset,
    int size) throws IOException 
{
    boolean success = false;
    try {
      fieldInfos = fn;
      cloneableFieldsStream = d.openInput(segment + ".fdt", readBufferSize);
      fieldsStream = (IndexInput) cloneableFieldsStream.clone();
      indexStream = d.openInput(segment + ".fdx", readBufferSize);
      if (docStoreOffset != -1) {
        // We read only a slice out of this shared fields file
        this.docStoreOffset = docStoreOffset;
        this.size = size;
        // Verify the file is long enough to hold all of our
        // docs
        assert ((int) (indexStream.length() / 8))  >= size + this.docStoreOffset;
      } else {
        this.docStoreOffset = 0;
        this.size = (int) (indexStream.length()  > > 3);
      }
      numTotalDocs = (int) (indexStream.length()  > > 3);
      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 (!closed) {
      if (fieldsStream != null) {
        fieldsStream.close();
      }
      if (cloneableFieldsStream != null) {
        cloneableFieldsStream.close();
      }
      if (indexStream != null) {
        indexStream.close();
      }
      IndexInput localFieldsStream = (IndexInput) fieldsStreamTL.get();
      if (localFieldsStream != null) {
        localFieldsStream.close();
        fieldsStreamTL.set(null);
      }
      closed = true;
    }
}

Closes the underlying org.apache.lucene.store.IndexInput streams, including any ones associated with a lazy implementation of a Field. This means that the Fields values will not be accessible.

 final Document doc(int n,
    FieldSelector fieldSelector) throws IOException, CorruptIndexException 
{
    indexStream.seek((n + docStoreOffset) * 8L);
    long position = indexStream.readLong();
    fieldsStream.seek(position);
    Document doc = new Document();
    int numFields = fieldsStream.readVInt();
    for (int i = 0; i <  numFields; i++) {
      int fieldNumber = fieldsStream.readVInt();
      FieldInfo fi = fieldInfos.fieldInfo(fieldNumber);
      FieldSelectorResult acceptField = fieldSelector == null ? FieldSelectorResult.LOAD : fieldSelector.accept(fi.name);
      byte bits = fieldsStream.readByte();
      assert bits < = FieldsWriter.FIELD_IS_COMPRESSED + FieldsWriter.FIELD_IS_TOKENIZED + FieldsWriter.FIELD_IS_BINARY;
      boolean compressed = (bits & FieldsWriter.FIELD_IS_COMPRESSED) != 0;
      boolean tokenize = (bits & FieldsWriter.FIELD_IS_TOKENIZED) != 0;
      boolean binary = (bits & FieldsWriter.FIELD_IS_BINARY) != 0;
      //TODO: Find an alternative approach here if this list continues to grow beyond the
      //list of 5 or 6 currently here.  See Lucene 762 for discussion
      if (acceptField.equals(FieldSelectorResult.LOAD)) {
        addField(doc, fi, binary, compressed, tokenize);
      }
      else if (acceptField.equals(FieldSelectorResult.LOAD_FOR_MERGE)) {
        addFieldForMerge(doc, fi, binary, compressed, tokenize);
      }
      else if (acceptField.equals(FieldSelectorResult.LOAD_AND_BREAK)){
        addField(doc, fi, binary, compressed, tokenize);
        break;//Get out of this loop
      }
      else if (acceptField.equals(FieldSelectorResult.LAZY_LOAD)) {
        addFieldLazy(doc, fi, binary, compressed, tokenize);
      }
      else if (acceptField.equals(FieldSelectorResult.SIZE)){
        skipField(binary, compressed, addFieldSize(doc, fi, binary, compressed));
      }
      else if (acceptField.equals(FieldSelectorResult.SIZE_AND_BREAK)){
        addFieldSize(doc, fi, binary, compressed);
        break;
      }
      else {
        skipField(binary, compressed);
      }
    }
    return doc;
}

 protected final  void ensureOpen() throws AlreadyClosedException 
{
    if (closed) {
      throw new AlreadyClosedException("this FieldsReader is closed");
    }
}

 final IndexInput rawDocs(int[] lengths,
    int startDocID,
    int numDocs) throws IOException 
{
    indexStream.seek((docStoreOffset+startDocID) * 8L);
    long startOffset = indexStream.readLong();
    long lastOffset = startOffset;
    int count = 0;
    while (count <  numDocs) {
      final long offset;
      final int docID = docStoreOffset + startDocID + count + 1;
      assert docID < = numTotalDocs;
      if (docID <  numTotalDocs) 
        offset = indexStream.readLong();
      else
        offset = fieldsStream.length();
      lengths[count++] = (int) (offset-lastOffset);
      lastOffset = offset;
    }
    fieldsStream.seek(startOffset);
    return fieldsStream;
}

Returns the length in bytes of each raw document in a contiguous range of length numDocs starting with startDocID. Returns the IndexInput (the fieldStream), already seeked to the starting point for startDocID.

 final int size() 
{
    return size;
}