import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase postingsWriter = new Lucene41PostingsWriter(state);

  boolean success = false;
  try {
    FieldsConsumer ret = new BlockTreeTermsWriter(state, 
                                                  postingsWriter,
                                                  minTermBlockSize, 
                                                  maxTermBlockSize);
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(postingsWriter);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
public FSTTermsWriter(SegmentWriteState state, PostingsWriterBase postingsWriter) throws IOException {
  final String termsFileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, TERMS_EXTENSION);

  this.postingsWriter = postingsWriter;
  this.fieldInfos = state.fieldInfos;
  this.out = state.directory.createOutput(termsFileName, state.context);

  boolean success = false;
  try {
    writeHeader(out);
    this.postingsWriter.init(out); 
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
public FSTOrdTermsWriter(SegmentWriteState state, PostingsWriterBase postingsWriter) throws IOException {
  final String termsIndexFileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, TERMS_INDEX_EXTENSION);
  final String termsBlockFileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, TERMS_BLOCK_EXTENSION);

  this.postingsWriter = postingsWriter;
  this.fieldInfos = state.fieldInfos;

  boolean success = false;
  try {
    this.indexOut = state.directory.createOutput(termsIndexFileName, state.context);
    this.blockOut = state.directory.createOutput(termsBlockFileName, state.context);
    writeHeader(indexOut);
    writeHeader(blockOut);
    this.postingsWriter.init(blockOut); 
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(indexOut, blockOut);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase postingsWriter = new Lucene41PostingsWriter(state);

  boolean success = false;
  try {
    FieldsConsumer ret = new OrdsBlockTreeTermsWriter(state, 
                                                      postingsWriter,
                                                      minTermBlockSize, 
                                                      maxTermBlockSize);
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(postingsWriter);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
public BlockTermsWriter(TermsIndexWriterBase termsIndexWriter,
    SegmentWriteState state, PostingsWriterBase postingsWriter)
    throws IOException {
  final String termsFileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, TERMS_EXTENSION);
  this.termsIndexWriter = termsIndexWriter;
  out = state.directory.createOutput(termsFileName, state.context);
  boolean success = false;
  try {
    fieldInfos = state.fieldInfos;
    writeHeader(out);
    currentField = null;
    this.postingsWriter = postingsWriter;
    // segment = state.segmentName;
    
    //System.out.println("BTW.init seg=" + state.segmentName);
    
    postingsWriter.init(out); // have consumer write its format/header
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase docsWriter = null;

  // Terms that have <= freqCutoff number of docs are
  // "pulsed" (inlined):
  PostingsWriterBase pulsingWriter = null;

  // Terms dict
  boolean success = false;
  try {
    docsWriter = wrappedPostingsBaseFormat.postingsWriterBase(state);

    // Terms that have <= freqCutoff number of docs are
    // "pulsed" (inlined):
    pulsingWriter = new PulsingPostingsWriter(state, freqCutoff, docsWriter);
    FieldsConsumer ret = new BlockTreeTermsWriter(state, pulsingWriter, minBlockSize, maxBlockSize);
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(docsWriter, pulsingWriter);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase postingsWriter = new IDVersionPostingsWriter(state);
  boolean success = false;
  try {
    FieldsConsumer ret = new VersionBlockTreeTermsWriter(state, 
                                                         postingsWriter,
                                                         minTermsInBlock, 
                                                         maxTermsInBlock);
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(postingsWriter);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  if (!LuceneTestCase.OLD_FORMAT_IMPERSONATION_IS_ACTIVE) {
    return super.fieldsConsumer(state);
  } else {
    PostingsWriterBase docs = new Lucene40PostingsWriter(state);
    
    // TODO: should we make the terms index more easily
    // pluggable?  Ie so that this codec would record which
    // index impl was used, and switch on loading?
    // Or... you must make a new Codec for this?
    boolean success = false;
    try {
      FieldsConsumer ret = new BlockTreeTermsWriter(state, docs, minBlockSize, maxBlockSize);
      success = true;
      return ret;
    } finally {
      if (!success) {
        docs.close();
      }
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
public BlockTermsWriter(TermsIndexWriterBase termsIndexWriter,
    SegmentWriteState state, PostingsWriterBase postingsWriter)
    throws IOException {
  final String termsFileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, TERMS_EXTENSION);
  this.termsIndexWriter = termsIndexWriter;
  out = state.directory.createOutput(termsFileName, state.context);
  boolean success = false;
  try {
    fieldInfos = state.fieldInfos;
    writeHeader(out);
    currentField = null;
    this.postingsWriter = postingsWriter;
    // segment = state.segmentName;
    
    //System.out.println("BTW.init seg=" + state.segmentName);
    
    postingsWriter.start(out); // have consumer write its format/header
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase docsWriter = null;

  // Terms that have <= freqCutoff number of docs are
  // "pulsed" (inlined):
  PostingsWriterBase pulsingWriter = null;

  // Terms dict
  boolean success = false;
  try {
    docsWriter = wrappedPostingsBaseFormat.postingsWriterBase(state);

    // Terms that have <= freqCutoff number of docs are
    // "pulsed" (inlined):
    pulsingWriter = new PulsingPostingsWriter(freqCutoff, docsWriter);
    FieldsConsumer ret = new BlockTreeTermsWriter(state, pulsingWriter, minBlockSize, maxBlockSize);
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(docsWriter, pulsingWriter);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase docs = new Lucene40PostingsWriter(state);

  // TODO: should we make the terms index more easily
  // pluggable?  Ie so that this codec would record which
  // index impl was used, and switch on loading?
  // Or... you must make a new Codec for this?
  boolean success = false;
  try {
    FieldsConsumer ret = new BlockTreeTermsWriter(state, docs, minBlockSize, maxBlockSize);
    success = true;
    return ret;
  } finally {
    if (!success) {
      docs.close();
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase postingsWriter = new Lucene41PostingsWriter(state);

  boolean success = false;
  try {
    FieldsConsumer ret = new FSTOrdTermsWriter(state, postingsWriter);
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(postingsWriter);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
  PostingsWriterBase postingsWriter = new Lucene41PostingsWriter(state);

  boolean success = false;
  try {
    FieldsConsumer ret = new FSTTermsWriter(state, postingsWriter);
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(postingsWriter);
    }
  }
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
TermsWriter(
    TermsIndexWriterBase.FieldWriter fieldIndexWriter,
    FieldInfo fieldInfo,
    PostingsWriterBase postingsWriter) 
{
  this.fieldInfo = fieldInfo;
  this.fieldIndexWriter = fieldIndexWriter;
  pendingTerms = new TermEntry[32];
  for(int i=0;i<pendingTerms.length;i++) {
    pendingTerms[i] = new TermEntry();
  }
  termsStartPointer = out.getFilePointer();
  this.postingsWriter = postingsWriter;
  this.longsSize = postingsWriter.setField(fieldInfo);
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
/** If the total number of positions (summed across all docs
 *  for this term) is <= maxPositions, then the postings are
 *  inlined into terms dict */
public PulsingPostingsWriter(SegmentWriteState state, int maxPositions, PostingsWriterBase wrappedPostingsWriter) {

  pending = new Position[maxPositions];
  for(int i=0;i<maxPositions;i++) {
    pending[i] = new Position();
  }
  fields = new ArrayList<>();

  // We simply wrap another postings writer, but only call
  // on it when tot positions is >= the cutoff:
  this.wrappedPostingsWriter = wrappedPostingsWriter;
  this.segmentState = state;
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
TermsWriter(
    TermsIndexWriterBase.FieldWriter fieldIndexWriter,
    FieldInfo fieldInfo,
    PostingsWriterBase postingsWriter) 
{
  this.fieldInfo = fieldInfo;
  this.fieldIndexWriter = fieldIndexWriter;
  pendingTerms = new TermEntry[32];
  for(int i=0;i<pendingTerms.length;i++) {
    pendingTerms[i] = new TermEntry();
  }
  termsStartPointer = out.getFilePointer();
  postingsWriter.setField(fieldInfo);
  this.postingsWriter = postingsWriter;
}
 

import org.apache.lucene.codecs.PostingsWriterBase; //导入依赖的package包/类
/** If the total number of positions (summed across all docs
 *  for this term) is <= maxPositions, then the postings are
 *  inlined into terms dict */
public PulsingPostingsWriter(int maxPositions, PostingsWriterBase wrappedPostingsWriter) {
  pending = new Position[maxPositions];
  for(int i=0;i<maxPositions;i++) {
    pending[i] = new Position();
  }

  // We simply wrap another postings writer, but only call
  // on it when tot positions is >= the cutoff:
  this.wrappedPostingsWriter = wrappedPostingsWriter;
}