Java BlockTermState类代码示例

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void encodeTerm(long[] longs, DataOutput out, FieldInfo fieldInfo, BlockTermState _state, boolean absolute) throws IOException {
  IntBlockTermState state = (IntBlockTermState)_state;
  if (absolute) {
    lastState = emptyState;
  }
  longs[0] = state.docStartFP - lastState.docStartFP;
  if (fieldHasPositions) {
    longs[1] = state.posStartFP - lastState.posStartFP;
    if (fieldHasPayloads || fieldHasOffsets) {
      longs[2] = state.payStartFP - lastState.payStartFP;
    }
  }
  if (state.singletonDocID != -1) {
    out.writeVInt(state.singletonDocID);
  }
  if (fieldHasPositions) {
    if (state.lastPosBlockOffset != -1) {
      out.writeVLong(state.lastPosBlockOffset);
    }
  }
  if (state.skipOffset != -1) {
    out.writeVLong(state.skipOffset);
  }
  lastState = state;
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void finishTerm(BytesRef text, TermStats stats) throws IOException {
  // write term meta data into fst
  final BlockTermState state = postingsWriter.newTermState();
  final FSTTermOutputs.TermData meta = new FSTTermOutputs.TermData();
  meta.longs = new long[longsSize];
  meta.bytes = null;
  meta.docFreq = state.docFreq = stats.docFreq;
  meta.totalTermFreq = state.totalTermFreq = stats.totalTermFreq;
  postingsWriter.finishTerm(state);
  postingsWriter.encodeTerm(meta.longs, metaWriter, fieldInfo, state, true);
  final int bytesSize = (int)metaWriter.getFilePointer();
  if (bytesSize > 0) {
    meta.bytes = new byte[bytesSize];
    metaWriter.writeTo(meta.bytes, 0);
    metaWriter.reset();
  }
  builder.add(Util.toIntsRef(text, scratchTerm), meta);
  numTerms++;
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public DocsEnum docs(FieldInfo fieldInfo, BlockTermState _termState, Bits liveDocs, DocsEnum reuse, int flags) throws IOException {
  final SepTermState termState = (SepTermState) _termState;
  SepDocsEnum docsEnum;
  if (reuse == null || !(reuse instanceof SepDocsEnum)) {
    docsEnum = new SepDocsEnum();
  } else {
    docsEnum = (SepDocsEnum) reuse;
    if (docsEnum.startDocIn != docIn) {
      // If you are using ParellelReader, and pass in a
      // reused DocsAndPositionsEnum, it could have come
      // from another reader also using sep codec
      docsEnum = new SepDocsEnum();        
    }
  }

  return docsEnum.init(fieldInfo, termState, liveDocs);
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public DocsAndPositionsEnum docsAndPositions(FieldInfo fieldInfo, BlockTermState _termState, Bits liveDocs,
                                             DocsAndPositionsEnum reuse, int flags)
  throws IOException {

  assert fieldInfo.getIndexOptions() == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
  final SepTermState termState = (SepTermState) _termState;
  SepDocsAndPositionsEnum postingsEnum;
  if (reuse == null || !(reuse instanceof SepDocsAndPositionsEnum)) {
    postingsEnum = new SepDocsAndPositionsEnum();
  } else {
    postingsEnum = (SepDocsAndPositionsEnum) reuse;
    if (postingsEnum.startDocIn != docIn) {
      // If you are using ParellelReader, and pass in a
      // reused DocsAndPositionsEnum, it could have come
      // from another reader also using sep codec
      postingsEnum = new SepDocsAndPositionsEnum();        
    }
  }

  return postingsEnum.init(fieldInfo, termState, liveDocs);
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void encodeTerm(long[] empty, DataOutput out, FieldInfo fieldInfo, BlockTermState _state, boolean absolute) throws IOException {
  PulsingTermState state = (PulsingTermState)_state;
  assert empty.length == 0;
  this.absolute = this.absolute || absolute;
  if (state.bytes == null) {
    wrappedPostingsWriter.encodeTerm(longs, buffer, fieldInfo, state.wrappedState, this.absolute);
    for (int i = 0; i < longsSize; i++) {
      out.writeVLong(longs[i]);
    }
    buffer.writeTo(out);
    buffer.reset();
    this.absolute = false;
  } else {
    out.writeVInt(state.bytes.length);
    out.writeBytes(state.bytes, 0, state.bytes.length);
    this.absolute = this.absolute || absolute;
  }
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
/** Called when we are done adding docs to this term */
@Override
public void finishTerm(BlockTermState _state) throws IOException {
  StandardTermState state = (StandardTermState)_state;
  // if (DEBUG) System.out.println("SPW: finishTerm seg=" + segment + " freqStart=" + freqStart);
  assert state.docFreq > 0;

  // TODO: wasteful we are counting this (counting # docs
  // for this term) in two places?
  assert state.docFreq == df;
  state.freqStart = freqStart;
  state.proxStart = proxStart;
  if (df >= skipMinimum) {
    state.skipOffset = skipListWriter.writeSkip(freqOut)-freqStart;
  } else {
    state.skipOffset = -1;
  }
  lastDocID = 0;
  df = 0;
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void encodeTerm(long[] empty, DataOutput out, FieldInfo fieldInfo, BlockTermState _state, boolean absolute) throws IOException {
  StandardTermState state = (StandardTermState)_state;
  if (absolute) {
    lastState = emptyState;
  }
  out.writeVLong(state.freqStart - lastState.freqStart);
  if (state.skipOffset != -1) {
    assert state.skipOffset > 0;
    out.writeVLong(state.skipOffset);
  }
  if (indexOptions.compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0) {
    out.writeVLong(state.proxStart - lastState.proxStart);
  }
  lastState = state;
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void readTermsBlock(IndexInput termsIn, FieldInfo fieldInfo, BlockTermState _termState) throws IOException {
  //System.out.println("PR.readTermsBlock state=" + _termState);
  final PulsingTermState termState = (PulsingTermState) _termState;
  if (termState.inlinedBytes == null) {
    termState.inlinedBytes = new byte[128];
    termState.inlinedBytesReader = new ByteArrayDataInput();
  }
  int len = termsIn.readVInt();
  //System.out.println("  len=" + len + " fp=" + termsIn.getFilePointer());
  if (termState.inlinedBytes.length < len) {
    termState.inlinedBytes = new byte[ArrayUtil.oversize(len, 1)];
  }
  termsIn.readBytes(termState.inlinedBytes, 0, len);
  termState.inlinedBytesReader.reset(termState.inlinedBytes);
  termState.wrappedTermState.termBlockOrd = 0;
  wrappedPostingsReader.readTermsBlock(termsIn, fieldInfo, termState.wrappedTermState);
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void readTermsBlock(IndexInput termsIn, FieldInfo fieldInfo, BlockTermState _termState) throws IOException {
  final StandardTermState termState = (StandardTermState) _termState;

  final int len = termsIn.readVInt();

  // if (DEBUG) System.out.println("  SPR.readTermsBlock bytes=" + len + " ts=" + _termState);
  if (termState.bytes == null) {
    termState.bytes = new byte[ArrayUtil.oversize(len, 1)];
    termState.bytesReader = new ByteArrayDataInput();
  } else if (termState.bytes.length < len) {
    termState.bytes = new byte[ArrayUtil.oversize(len, 1)];
  }

  termsIn.readBytes(termState.bytes, 0, len);
  termState.bytesReader.reset(termState.bytes, 0, len);
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void readTermsBlock(IndexInput termsIn, FieldInfo fieldInfo, BlockTermState _termState) throws IOException {
  final IntBlockTermState termState = (IntBlockTermState) _termState;

  final int numBytes = termsIn.readVInt();

  if (termState.bytes == null) {
    termState.bytes = new byte[ArrayUtil.oversize(numBytes, 1)];
    termState.bytesReader = new ByteArrayDataInput();
  } else if (termState.bytes.length < numBytes) {
    termState.bytes = new byte[ArrayUtil.oversize(numBytes, 1)];
  }

  termsIn.readBytes(termState.bytes, 0, numBytes);
  termState.bytesReader.reset(termState.bytes, 0, numBytes);
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void decodeTerm(long[] longs, DataInput in, FieldInfo fieldInfo, BlockTermState _termState, boolean absolute)
  throws IOException {
  final StandardTermState termState = (StandardTermState) _termState;
  // if (DEBUG) System.out.println("SPR: nextTerm seg=" + segment + " tbOrd=" + termState.termBlockOrd + " bytesReader.fp=" + termState.bytesReader.getPosition());
  final boolean isFirstTerm = termState.termBlockOrd == 0;
  if (absolute) {
    termState.freqOffset = 0;
    termState.proxOffset = 0;
  }

  termState.freqOffset += in.readVLong();
  /*
  if (DEBUG) {
    System.out.println("  dF=" + termState.docFreq);
    System.out.println("  freqFP=" + termState.freqOffset);
  }
  */
  assert termState.freqOffset < freqIn.length();

  if (termState.docFreq >= skipMinimum) {
    termState.skipOffset = in.readVLong();
    // if (DEBUG) System.out.println("  skipOffset=" + termState.skipOffset + " vs freqIn.length=" + freqIn.length());
    assert termState.freqOffset + termState.skipOffset < freqIn.length();
  } else {
    // undefined
  }

  if (fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0) {
    termState.proxOffset += in.readVLong();
    // if (DEBUG) System.out.println("  proxFP=" + termState.proxOffset);
  }
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public DocsEnum docs(FieldInfo fieldInfo, BlockTermState termState, Bits liveDocs, DocsEnum reuse, int flags) throws IOException {
  if (canReuse(reuse, liveDocs)) {
    // if (DEBUG) System.out.println("SPR.docs ts=" + termState);
    return ((SegmentDocsEnumBase) reuse).reset(fieldInfo, (StandardTermState)termState);
  }
  return newDocsEnum(liveDocs, fieldInfo, (StandardTermState)termState);
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public DocsEnum docs(FieldInfo fieldInfo, BlockTermState termState, Bits liveDocs, DocsEnum reuse, int flags) throws IOException {
  BlockDocsEnum docsEnum;
  if (reuse instanceof BlockDocsEnum) {
    docsEnum = (BlockDocsEnum) reuse;
    if (!docsEnum.canReuse(docIn, fieldInfo)) {
      docsEnum = new BlockDocsEnum(fieldInfo);
    }
  } else {
    docsEnum = new BlockDocsEnum(fieldInfo);
  }
  return docsEnum.reset(liveDocs, (IntBlockTermState) termState, flags);
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public DocsAndPositionsEnum docsAndPositions(FieldInfo fieldInfo, BlockTermState termState, Bits liveDocs,
                                             DocsAndPositionsEnum reuse, int flags)
  throws IOException {

  boolean indexHasOffsets = fieldInfo.getIndexOptions().compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
  boolean indexHasPayloads = fieldInfo.hasPayloads();

  if ((!indexHasOffsets || (flags & DocsAndPositionsEnum.FLAG_OFFSETS) == 0) &&
      (!indexHasPayloads || (flags & DocsAndPositionsEnum.FLAG_PAYLOADS) == 0)) {
    BlockDocsAndPositionsEnum docsAndPositionsEnum;
    if (reuse instanceof BlockDocsAndPositionsEnum) {
      docsAndPositionsEnum = (BlockDocsAndPositionsEnum) reuse;
      if (!docsAndPositionsEnum.canReuse(docIn, fieldInfo)) {
        docsAndPositionsEnum = new BlockDocsAndPositionsEnum(fieldInfo);
      }
    } else {
      docsAndPositionsEnum = new BlockDocsAndPositionsEnum(fieldInfo);
    }
    return docsAndPositionsEnum.reset(liveDocs, (IntBlockTermState) termState);
  } else {
    EverythingEnum everythingEnum;
    if (reuse instanceof EverythingEnum) {
      everythingEnum = (EverythingEnum) reuse;
      if (!everythingEnum.canReuse(docIn, fieldInfo)) {
        everythingEnum = new EverythingEnum(fieldInfo);
      }
    } else {
      everythingEnum = new EverythingEnum(fieldInfo);
    }
    return everythingEnum.reset(liveDocs, (IntBlockTermState) termState, flags);
  }
}
 

import org.apache.lucene.codecs.BlockTermState; //导入依赖的package包/类
@Override
public void finishTerm(BytesRef text, TermStats stats) throws IOException {
  if (numTerms > 0 && numTerms % SKIP_INTERVAL == 0) {
    bufferSkip();
  }
  // write term meta data into fst
  final long longs[] = new long[longsSize];
  final long delta = stats.totalTermFreq - stats.docFreq;
  if (stats.totalTermFreq > 0) {
    if (delta == 0) {
      statsOut.writeVInt(stats.docFreq<<1|1);
    } else {
      statsOut.writeVInt(stats.docFreq<<1|0);
      statsOut.writeVLong(stats.totalTermFreq-stats.docFreq);
    }
  } else {
    statsOut.writeVInt(stats.docFreq);
  }
  BlockTermState state = postingsWriter.newTermState();
  state.docFreq = stats.docFreq;
  state.totalTermFreq = stats.totalTermFreq;
  postingsWriter.finishTerm(state);
  postingsWriter.encodeTerm(longs, metaBytesOut, fieldInfo, state, true);
  for (int i = 0; i < longsSize; i++) {
    metaLongsOut.writeVLong(longs[i] - lastLongs[i]);
    lastLongs[i] = longs[i];
  }
  metaLongsOut.writeVLong(metaBytesOut.getFilePointer() - lastMetaBytesFP);

  builder.add(Util.toIntsRef(text, scratchTerm), numTerms);
  numTerms++;

  lastMetaBytesFP = metaBytesOut.getFilePointer();
}