TermVectorsReader(Directory d,
    String segment,
    FieldInfos fieldInfos) throws IOException, CorruptIndexException 
{
       
    this(d, segment, fieldInfos, BufferedIndexInput.BUFFER_SIZE);
}

 TermVectorsReader(Directory d,
    String segment,
    FieldInfos fieldInfos,
    int readBufferSize) throws IOException, CorruptIndexException 
{
    this(d, segment, fieldInfos, BufferedIndexInput.BUFFER_SIZE, -1, 0);
}

 TermVectorsReader(Directory d,
    String segment,
    FieldInfos fieldInfos,
    int readBufferSize,
    int docStoreOffset,
    int size) throws IOException, CorruptIndexException 
{
    boolean success = false;
    try {
      if (d.fileExists(segment + "." + IndexFileNames.VECTORS_INDEX_EXTENSION)) {
        tvx = d.openInput(segment + "." + IndexFileNames.VECTORS_INDEX_EXTENSION, readBufferSize);
        checkValidFormat(tvx);
        tvd = d.openInput(segment + "." + IndexFileNames.VECTORS_DOCUMENTS_EXTENSION, readBufferSize);
        tvdFormat = checkValidFormat(tvd);
        tvf = d.openInput(segment + "." + IndexFileNames.VECTORS_FIELDS_EXTENSION, readBufferSize);
        tvfFormat = checkValidFormat(tvf);
        if (-1 == docStoreOffset) {
          this.docStoreOffset = 0;
          this.size = (int) (tvx.length()  > > 3);
        } else {
          this.docStoreOffset = docStoreOffset;
          this.size = size;
          // Verify the file is long enough to hold all of our
          // docs
          assert ((int) (tvx.length() / 8))  >= size + docStoreOffset;
        }
      }
      this.fieldInfos = fieldInfos;
      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();
      }
    }
}

 protected Object clone() 
{
    
    if (tvx == null || tvd == null || tvf == null)
      return null;
    TermVectorsReader clone = null;
    try {
      clone = (TermVectorsReader) super.clone();
    } catch (CloneNotSupportedException e) {}
    clone.tvx = (IndexInput) tvx.clone();
    clone.tvd = (IndexInput) tvd.clone();
    clone.tvf = (IndexInput) tvf.clone();
    return clone;
}

  void close() throws IOException 
{
  	// make all effort to close up. Keep the first exception
  	// and throw it as a new one.
  	IOException keep = null;
  	if (tvx != null) try { tvx.close(); } catch (IOException e) { if (keep == null) keep = e; }
  	if (tvd != null) try { tvd.close(); } catch (IOException e) { if (keep == null) keep = e; }
  	if (tvf  != null) try {  tvf.close(); } catch (IOException e) { if (keep == null) keep = e; }
  	if (keep != null) throw (IOException) keep.fillInStackTrace();
}

 TermFreqVector[] get(int docNum) throws IOException 
{
    TermFreqVector[] result = null;
    if (tvx != null) {
      //We need to offset by
      tvx.seek(((docNum + docStoreOffset) * 8L) + FORMAT_SIZE);
      long position = tvx.readLong();
      tvd.seek(position);
      int fieldCount = tvd.readVInt();
      // No fields are vectorized for this document
      if (fieldCount != 0) {
        int number = 0;
        String[] fields = new String[fieldCount];
        for (int i = 0; i <  fieldCount; i++) {
          if(tvdFormat == FORMAT_VERSION)
            number = tvd.readVInt();
          else
            number += tvd.readVInt();
          fields[i] = fieldInfos.fieldName(number);
        }
        // Compute position in the tvf file
        position = 0;
        long[] tvfPointers = new long[fieldCount];
        for (int i = 0; i <  fieldCount; i++) {
          position += tvd.readVLong();
          tvfPointers[i] = position;
        }
        result = readTermVectors(docNum, fields, tvfPointers);
      }
    } else {
      //System.out.println("No tvx file");
    }
    return result;
}

Return all term vectors stored for this document or null if the could not be read in.

 TermFreqVector get(int docNum,
    String field) throws IOException 
{
    // Check if no term vectors are available for this segment at all
    ParallelArrayTermVectorMapper mapper = new ParallelArrayTermVectorMapper();
    get(docNum, field, mapper);
    return mapper.materializeVector();
}

Retrieve the term vector for the given document and field

 public  void get(int docNumber,
    TermVectorMapper mapper) throws IOException 
{
    // Check if no term vectors are available for this segment at all
    if (tvx != null) {
      //We need to offset by
      tvx.seek((docNumber * 8L) + FORMAT_SIZE);
      long position = tvx.readLong();
      tvd.seek(position);
      int fieldCount = tvd.readVInt();
      // No fields are vectorized for this document
      if (fieldCount != 0) {
        int number = 0;
        String[] fields = new String[fieldCount];
        for (int i = 0; i <  fieldCount; i++) {
          if(tvdFormat == FORMAT_VERSION)
            number = tvd.readVInt();
          else
            number += tvd.readVInt();
          fields[i] = fieldInfos.fieldName(number);
        }
        // Compute position in the tvf file
        position = 0;
        long[] tvfPointers = new long[fieldCount];
        for (int i = 0; i <  fieldCount; i++) {
          position += tvd.readVLong();
          tvfPointers[i] = position;
        }
        mapper.setDocumentNumber(docNumber);
        readTermVectors(fields, tvfPointers, mapper);
      }
    } else {
      //System.out.println("No tvx file");
    }
}

 public  void get(int docNum,
    String field,
    TermVectorMapper mapper) throws IOException 
{
    if (tvx != null) {
      int fieldNumber = fieldInfos.fieldNumber(field);
      //We need to account for the FORMAT_SIZE at when seeking in the tvx
      //We don't need to do this in other seeks because we already have the
      // file pointer
      //that was written in another file
      tvx.seek(((docNum + docStoreOffset) * 8L) + FORMAT_SIZE);
      //System.out.println("TVX Pointer: " + tvx.getFilePointer());
      long position = tvx.readLong();
      tvd.seek(position);
      int fieldCount = tvd.readVInt();
      //System.out.println("Num Fields: " + fieldCount);
      // There are only a few fields per document. We opt for a full scan
      // rather then requiring that they be ordered. We need to read through
      // all of the fields anyway to get to the tvf pointers.
      int number = 0;
      int found = -1;
      for (int i = 0; i <  fieldCount; i++) {
        if(tvdFormat == FORMAT_VERSION)
          number = tvd.readVInt();
        else
          number += tvd.readVInt();
        if (number == fieldNumber)
          found = i;
      }
      // This field, although valid in the segment, was not found in this
      // document
      if (found != -1) {
        // Compute position in the tvf file
        position = 0;
        for (int i = 0; i < = found; i++)
          position += tvd.readVLong();
        mapper.setDocumentNumber(docNum);
        readTermVector(field, position, mapper);
      } else {
        //System.out.println("Fieldable not found");
      }
    } else {
      //System.out.println("No tvx file");
    }
}

 int size() 
{
    return size;
}