Java IndexOutput.writeVInt方法代码示例

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
public void close() throws IOException {
  wrappedPostingsWriter.close();
  if (wrappedPostingsWriter instanceof PulsingPostingsWriter ||
      VERSION_CURRENT < VERSION_META_ARRAY) {
    return;
  }
  String summaryFileName = IndexFileNames.segmentFileName(segmentState.segmentInfo.name, segmentState.segmentSuffix, SUMMARY_EXTENSION);
  IndexOutput out = null;
  try {
    out = segmentState.directory.createOutput(summaryFileName, segmentState.context);
    CodecUtil.writeHeader(out, CODEC, VERSION_CURRENT);
    out.writeVInt(fields.size());
    for (FieldMetaData field : fields) {
      out.writeVInt(field.fieldNumber);
      out.writeVInt(field.longsSize);
    }
    out.close();
  } finally {
    IOUtils.closeWhileHandlingException(out);
  }
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
private void addPositions(final DocsAndPositionsEnum in, final IndexOutput out) throws IOException {
  int freq = in.freq();
  out.writeVInt(freq);
  int previousPosition = 0;
  int previousEndOffset = 0;
  for (int i = 0; i < freq; i++) {
    final int pos = in.nextPosition();
    final BytesRef payload = in.getPayload();
    // The low-order bit of token is set only if there is a payload, the
    // previous bits are the delta-encoded position. 
    final int token = (pos - previousPosition) << 1 | (payload == null ? 0 : 1);
    out.writeVInt(token);
    previousPosition = pos;
    if (storeOffsets) { // don't encode offsets if they are not stored
      final int startOffset = in.startOffset();
      final int endOffset = in.endOffset();
      out.writeVInt(startOffset - previousEndOffset);
      out.writeVInt(endOffset - startOffset);
      previousEndOffset = endOffset;
    }
    if (payload != null) {
      out.writeVInt(payload.length);
      out.writeBytes(payload.bytes, payload.offset, payload.length);
    }
  }
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
/** Write as a d-gaps list */
private void writeDgaps(IndexOutput output) throws IOException {
  output.writeInt(-1);            // mark using d-gaps                         
  output.writeInt(size());        // write size
  output.writeInt(count());       // write count
  int last=0;
  int n = count();
  int m = bits.length;
  for (int i=0; i<m && n>0; i++) {
    if (bits[i]!=0) {
      output.writeVInt(i-last);
      output.writeByte(bits[i]);
      last = i;
      n -= BYTE_COUNTS[bits[i] & 0xFF];
    }
  }
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
protected void writeSkipData(int level, IndexOutput skipBuffer) throws IOException {
  int delta = curDoc - lastSkipDoc[level];
  // if (DEBUG) {
  //   System.out.println("writeSkipData level=" + level + " lastDoc=" + curDoc + " delta=" + delta + " curDocPointer=" + curDocPointer);
  // }
  skipBuffer.writeVInt(delta);
  lastSkipDoc[level] = curDoc;

  skipBuffer.writeVInt((int) (curDocPointer - lastSkipDocPointer[level]));
  lastSkipDocPointer[level] = curDocPointer;

  if (fieldHasPositions) {
    // if (DEBUG) {
    //   System.out.println("  curPosPointer=" + curPosPointer + " curPosBufferUpto=" + curPosBufferUpto);
    // }
    skipBuffer.writeVInt((int) (curPosPointer - lastSkipPosPointer[level]));
    lastSkipPosPointer[level] = curPosPointer;
    skipBuffer.writeVInt(curPosBufferUpto);

    if (fieldHasPayloads) {
      skipBuffer.writeVInt(curPayloadByteUpto);
    }

    if (fieldHasOffsets || fieldHasPayloads) {
      skipBuffer.writeVInt((int) (curPayPointer - lastSkipPayPointer[level]));
      lastSkipPayPointer[level] = curPayPointer;
    }
  }
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
synchronized private void persist() throws IOException {
  String fileName = SNAPSHOTS_PREFIX + nextWriteGen;
  IndexOutput out = dir.createOutput(fileName, IOContext.DEFAULT);
  boolean success = false;
  try {
    CodecUtil.writeHeader(out, CODEC_NAME, VERSION_CURRENT);   
    out.writeVInt(refCounts.size());
    for(Entry<Long,Integer> ent : refCounts.entrySet()) {
      out.writeVLong(ent.getKey());
      out.writeVInt(ent.getValue());
    }
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
      IOUtils.deleteFilesIgnoringExceptions(dir, fileName);
    } else {
      IOUtils.close(out);
    }
  }

  dir.sync(Collections.singletonList(fileName));
  
  if (nextWriteGen > 0) {
    String lastSaveFile = SNAPSHOTS_PREFIX + (nextWriteGen-1);
    // exception OK: likely it didn't exist
    IOUtils.deleteFilesIgnoringExceptions(dir, lastSaveFile);
  }

  nextWriteGen++;
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {

  final String fileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
  final IndexOutput out = state.directory.createOutput(fileName, state.context);
  boolean success = false;
  try {
    CodecUtil.writeHeader(out, CODEC_NAME, VERSION_CURRENT);
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
    }
  }
  
  return new FieldsConsumer() {
    @Override
    public TermsConsumer addField(FieldInfo field) {
      //System.out.println("\naddField field=" + field.name);
      return new TermsWriter(out, field, doPackFST, acceptableOverheadRatio);
    }

    @Override
    public void close() throws IOException {
      // EOF marker:
      try {
        out.writeVInt(0);
        CodecUtil.writeFooter(out);
      } finally {
        out.close();
      }
    }
  };
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
public void init(IndexOutput termsOut) throws IOException {
  this.termsOut = termsOut;
  CodecUtil.writeHeader(termsOut, CODEC, VERSION_CURRENT);
  termsOut.writeVInt(pending.length); // encode maxPositions in header
  wrappedPostingsWriter.init(termsOut);
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
public FieldsConsumer fieldsConsumer(SegmentWriteState writeState) throws IOException {
  final int id = nextID.getAndIncrement();

  // TODO -- ok to do this up front instead of
  // on close....?  should be ok?
  // Write our ID:
  final String idFileName = IndexFileNames.segmentFileName(writeState.segmentInfo.name, writeState.segmentSuffix, ID_EXTENSION);
  IndexOutput out = writeState.directory.createOutput(idFileName, writeState.context);
  boolean success = false;
  try {
    CodecUtil.writeHeader(out, RAM_ONLY_NAME, VERSION_LATEST);
    out.writeVInt(id);
    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
    } else {
      IOUtils.close(out);
    }
  }
  
  final RAMPostings postings = new RAMPostings();
  final RAMFieldsConsumer consumer = new RAMFieldsConsumer(postings);

  synchronized(state) {
    state.put(id, postings);
  }
  return consumer;
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
public IntIndexOutput createOutput(Directory dir, String fileName, IOContext context) throws IOException {
  final IndexOutput out = dir.createOutput(fileName, context);
  boolean success = false;
  try {
    out.writeInt(baseBlockSize);
    VariableIntBlockIndexOutput ret = new VariableIntBlockIndexOutput(out, 2*baseBlockSize) {
      int pendingCount;
      final int[] buffer = new int[2+2*baseBlockSize];
      
      @Override
      protected int add(int value) throws IOException {
        buffer[pendingCount++] = value;
        // silly variable block length int encoder: if
        // first value <= 3, we write N vints at once;
        // else, 2*N
        final int flushAt = buffer[0] <= 3 ? baseBlockSize : 2*baseBlockSize;
        
        // intentionally be non-causal here:
        if (pendingCount == flushAt+1) {
          for(int i=0;i<flushAt;i++) {
            out.writeVInt(buffer[i]);
          }
          buffer[0] = buffer[flushAt];
          pendingCount = 1;
          return flushAt;
        } else {
          return 0;
        }
      }
    };
    success = true;
    return ret;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(out);
    }
  }
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
protected void writeSkipData(int level, IndexOutput skipBuffer) throws IOException {
  int delta = curDoc - lastSkipDoc[level];
  // if (DEBUG) {
  //   System.out.println("writeSkipData level=" + level + " lastDoc=" + curDoc + " delta=" + delta + " curDocPointer=" + curDocPointer);
  // }
  skipBuffer.writeVInt(delta);
  lastSkipDoc[level] = curDoc;

  skipBuffer.writeVLong(curDocPointer - lastSkipDocPointer[level]);
  lastSkipDocPointer[level] = curDocPointer;

  if (fieldHasPositions) {
    // if (DEBUG) {
    //   System.out.println("  curPosPointer=" + curPosPointer + " curPosBufferUpto=" + curPosBufferUpto);
    // }
    skipBuffer.writeVLong(curPosPointer - lastSkipPosPointer[level]);
    lastSkipPosPointer[level] = curPosPointer;
    skipBuffer.writeVInt(curPosBufferUpto);

    if (fieldHasPayloads) {
      skipBuffer.writeVInt(curPayloadByteUpto);
    }

    if (fieldHasOffsets || fieldHasPayloads) {
      skipBuffer.writeVLong(curPayPointer - lastSkipPayPointer[level]);
      lastSkipPayPointer[level] = curPayPointer;
    }
  }
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
private static void writeBytesRef(IndexOutput out, BytesRef bytes) throws IOException {
  out.writeVInt(bytes.length);
  out.writeBytes(bytes.bytes, bytes.offset, bytes.length);
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
public void init(IndexOutput termsOut) throws IOException {
  CodecUtil.writeHeader(termsOut, TERMS_CODEC, VERSION_CURRENT);
  termsOut.writeVInt(BLOCK_SIZE);
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
protected FixedIntBlockIndexOutput(IndexOutput out, int fixedBlockSize) throws IOException {
  blockSize = fixedBlockSize;
  this.out = out;
  out.writeVInt(blockSize);
  buffer = new int[blockSize];
}
 

import org.apache.lucene.store.IndexOutput; //导入方法依赖的package包/类
@Override
protected void writeSkipData(int level, IndexOutput skipBuffer) throws IOException {
  // To efficiently store payloads in the posting lists we do not store the length of
  // every payload. Instead we omit the length for a payload if the previous payload had
  // the same length.
  // However, in order to support skipping the payload length at every skip point must be known.
  // So we use the same length encoding that we use for the posting lists for the skip data as well:
  // Case 1: current field does not store payloads
  //           SkipDatum                 --> DocSkip, FreqSkip, ProxSkip
  //           DocSkip,FreqSkip,ProxSkip --> VInt
  //           DocSkip records the document number before every SkipInterval th  document in TermFreqs. 
  //           Document numbers are represented as differences from the previous value in the sequence.
  // Case 2: current field stores payloads
  //           SkipDatum                 --> DocSkip, PayloadLength?, FreqSkip,ProxSkip
  //           DocSkip,FreqSkip,ProxSkip --> VInt
  //           PayloadLength             --> VInt    
  //         In this case DocSkip/2 is the difference between
  //         the current and the previous value. If DocSkip
  //         is odd, then a PayloadLength encoded as VInt follows,
  //         if DocSkip is even, then it is assumed that the
  //         current payload length equals the length at the previous
  //         skip point
  if (curStorePayloads) {
    int delta = curDoc - lastSkipDoc[level];
    if (curPayloadLength == lastSkipPayloadLength[level]) {
      // the current payload length equals the length at the previous skip point,
      // so we don't store the length again
      skipBuffer.writeVInt(delta * 2);
    } else {
      // the payload length is different from the previous one. We shift the DocSkip, 
      // set the lowest bit and store the current payload length as VInt.
      skipBuffer.writeVInt(delta * 2 + 1);
      skipBuffer.writeVInt(curPayloadLength);
      lastSkipPayloadLength[level] = curPayloadLength;
    }
  } else {
    // current field does not store payloads
    skipBuffer.writeVInt(curDoc - lastSkipDoc[level]);
  }

  skipBuffer.writeVInt((int) (curFreqPointer - lastSkipFreqPointer[level]));
  skipBuffer.writeVInt((int) (curProxPointer - lastSkipProxPointer[level]));

  lastSkipDoc[level] = curDoc;
  
  lastSkipFreqPointer[level] = curFreqPointer;
  lastSkipProxPointer[level] = curProxPointer;
}