Java IndexInput.readVLong方法代码示例

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
public CompressedIndexInput(IndexInput in) throws IOException {
    super("compressed(" + in.toString() + ")");
    this.in = in;
    readHeader(in);
    this.version = in.readInt();
    long metaDataPosition = in.readLong();
    long headerLength = in.getFilePointer();
    in.seek(metaDataPosition);
    this.totalUncompressedLength = in.readVLong();
    int size = in.readVInt();
    offsets = BigArrays.NON_RECYCLING_INSTANCE.newLongArray(size);
    for (int i = 0; i < size; i++) {
        offsets.set(i, in.readVLong());
    }
    this.currentOffsetIdx = -1;
    this.currentUncompressedChunkPointer = 0;
    in.seek(headerLength);
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static NumericEntry readNumericEntry(IndexInput meta) throws IOException {
  NumericEntry entry = new NumericEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.packedIntsVersion = meta.readVInt();
  entry.offset = meta.readLong();
  entry.count = meta.readVLong();
  entry.blockSize = meta.readVInt();
  switch(entry.format) {
    case GCD_COMPRESSED:
      entry.minValue = meta.readLong();
      entry.gcd = meta.readLong();
      break;
    case TABLE_COMPRESSED:
      if (entry.count > Integer.MAX_VALUE) {
        throw new CorruptIndexException("Cannot use TABLE_COMPRESSED with more than MAX_VALUE values, input=" + meta);
      }
      final int uniqueValues = meta.readVInt();
      if (uniqueValues > 256) {
        throw new CorruptIndexException("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + meta);
      }
      entry.table = new long[uniqueValues];
      for (int i = 0; i < uniqueValues; ++i) {
        entry.table[i] = meta.readLong();
      }
      break;
    case DELTA_COMPRESSED:
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static BinaryEntry readBinaryEntry(IndexInput meta) throws IOException {
  BinaryEntry entry = new BinaryEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.minLength = meta.readVInt();
  entry.maxLength = meta.readVInt();
  entry.count = meta.readVLong();
  entry.offset = meta.readLong();
  switch(entry.format) {
    case BINARY_FIXED_UNCOMPRESSED:
      break;
    case BINARY_PREFIX_COMPRESSED:
      entry.addressInterval = meta.readVInt();
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    case BINARY_VARIABLE_UNCOMPRESSED:
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static NumericEntry readNumericEntry(IndexInput meta) throws IOException {
  NumericEntry entry = new NumericEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.offset = meta.readLong();
  entry.count = meta.readVLong();
  switch(entry.format) {
    case GCD_COMPRESSED:
      entry.minValue = meta.readLong();
      entry.gcd = meta.readLong();
      entry.bitsPerValue = meta.readVInt();
      break;
    case TABLE_COMPRESSED:
      final int uniqueValues = meta.readVInt();
      if (uniqueValues > 256) {
        throw new CorruptIndexException("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + meta);
      }
      entry.table = new long[uniqueValues];
      for (int i = 0; i < uniqueValues; ++i) {
        entry.table[i] = meta.readLong();
      }
      entry.bitsPerValue = meta.readVInt();
      break;
    case DELTA_COMPRESSED:
      entry.minValue = meta.readLong();
      entry.bitsPerValue = meta.readVInt();
      break;
    case MONOTONIC_COMPRESSED:
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  entry.endOffset = meta.readLong();
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static BinaryEntry readBinaryEntry(IndexInput meta) throws IOException {
  BinaryEntry entry = new BinaryEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.minLength = meta.readVInt();
  entry.maxLength = meta.readVInt();
  entry.count = meta.readVLong();
  entry.offset = meta.readLong();
  switch(entry.format) {
    case BINARY_FIXED_UNCOMPRESSED:
      break;
    case BINARY_PREFIX_COMPRESSED:
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      entry.reverseIndexOffset = meta.readLong();
      break;
    case BINARY_VARIABLE_UNCOMPRESSED:
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
private MonotonicBlockPackedReader(IndexInput in, int packedIntsVersion, int blockSize, long valueCount, boolean direct) throws IOException {
  this.valueCount = valueCount;
  blockShift = checkBlockSize(blockSize, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE);
  blockMask = blockSize - 1;
  final int numBlocks = numBlocks(valueCount, blockSize);
  minValues = new long[numBlocks];
  averages = new float[numBlocks];
  subReaders = new PackedInts.Reader[numBlocks];
  for (int i = 0; i < numBlocks; ++i) {
    if (packedIntsVersion < PackedInts.VERSION_MONOTONIC_WITHOUT_ZIGZAG) {
      minValues[i] = in.readVLong();
    } else {
      minValues[i] = in.readZLong();
    }
    averages[i] = Float.intBitsToFloat(in.readInt());
    final int bitsPerValue = in.readVInt();
    if (bitsPerValue > 64) {
      throw new IOException("Corrupted");
    }
    if (bitsPerValue == 0) {
      subReaders[i] = new PackedInts.NullReader(blockSize);
    } else {
      final int size = (int) Math.min(blockSize, valueCount - (long) i * blockSize);
      if (direct) {
        final long pointer = in.getFilePointer();
        subReaders[i] = PackedInts.getDirectReaderNoHeader(in, PackedInts.Format.PACKED, packedIntsVersion, size, bitsPerValue);
        in.seek(pointer + PackedInts.Format.PACKED.byteCount(packedIntsVersion, size, bitsPerValue));
      } else {
        subReaders[i] = PackedInts.getReaderNoHeader(in, PackedInts.Format.PACKED, packedIntsVersion, size, bitsPerValue);
      }
    }
  }
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
private BinaryDocValues loadBytesVarStraight(FieldInfo field) throws IOException {
  String dataName = IndexFileNames.segmentFileName(state.segmentInfo.name + "_" + Integer.toString(field.number), segmentSuffix, "dat");
  String indexName = IndexFileNames.segmentFileName(state.segmentInfo.name + "_" + Integer.toString(field.number), segmentSuffix, "idx");
  IndexInput data = null;
  IndexInput index = null;
  boolean success = false;
  try {
    data = dir.openInput(dataName, state.context);
    CodecUtil.checkHeader(data, Lucene40DocValuesFormat.BYTES_VAR_STRAIGHT_CODEC_NAME_DAT,
                                Lucene40DocValuesFormat.BYTES_VAR_STRAIGHT_VERSION_START,
                                Lucene40DocValuesFormat.BYTES_VAR_STRAIGHT_VERSION_CURRENT);
    index = dir.openInput(indexName, state.context);
    CodecUtil.checkHeader(index, Lucene40DocValuesFormat.BYTES_VAR_STRAIGHT_CODEC_NAME_IDX,
                                 Lucene40DocValuesFormat.BYTES_VAR_STRAIGHT_VERSION_START,
                                 Lucene40DocValuesFormat.BYTES_VAR_STRAIGHT_VERSION_CURRENT);
    long totalBytes = index.readVLong();
    PagedBytes bytes = new PagedBytes(16);
    bytes.copy(data, totalBytes);
    final PagedBytes.Reader bytesReader = bytes.freeze(true);
    final PackedInts.Reader reader = PackedInts.getReader(index);
    CodecUtil.checkEOF(data);
    CodecUtil.checkEOF(index);
    success = true;
    ramBytesUsed.addAndGet(bytesReader.ramBytesUsed() + reader.ramBytesUsed());
    return new BinaryDocValues() {
      @Override
      public BytesRef get(int docID) {
        final BytesRef term = new BytesRef();
        long startAddress = reader.get(docID);
        long endAddress = reader.get(docID+1);
        bytesReader.fillSlice(term, startAddress, (int)(endAddress - startAddress));
        return term;
      }
    };
  } finally {
    if (success) {
      IOUtils.close(data, index);
    } else {
      IOUtils.closeWhileHandlingException(data, index);
    }
  }
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
CompressingStoredFieldsIndexReader(IndexInput fieldsIndexIn, SegmentInfo si) throws IOException {
  maxDoc = si.getDocCount();
  int[] docBases = new int[16];
  long[] startPointers = new long[16];
  int[] avgChunkDocs = new int[16];
  long[] avgChunkSizes = new long[16];
  PackedInts.Reader[] docBasesDeltas = new PackedInts.Reader[16];
  PackedInts.Reader[] startPointersDeltas = new PackedInts.Reader[16];

  final int packedIntsVersion = fieldsIndexIn.readVInt();

  int blockCount = 0;

  for (;;) {
    final int numChunks = fieldsIndexIn.readVInt();
    if (numChunks == 0) {
      break;
    }
    if (blockCount == docBases.length) {
      final int newSize = ArrayUtil.oversize(blockCount + 1, 8);
      docBases = Arrays.copyOf(docBases, newSize);
      startPointers = Arrays.copyOf(startPointers, newSize);
      avgChunkDocs = Arrays.copyOf(avgChunkDocs, newSize);
      avgChunkSizes = Arrays.copyOf(avgChunkSizes, newSize);
      docBasesDeltas = Arrays.copyOf(docBasesDeltas, newSize);
      startPointersDeltas = Arrays.copyOf(startPointersDeltas, newSize);
    }

    // doc bases
    docBases[blockCount] = fieldsIndexIn.readVInt();
    avgChunkDocs[blockCount] = fieldsIndexIn.readVInt();
    final int bitsPerDocBase = fieldsIndexIn.readVInt();
    if (bitsPerDocBase > 32) {
      throw new CorruptIndexException("Corrupted bitsPerDocBase (resource=" + fieldsIndexIn + ")");
    }
    docBasesDeltas[blockCount] = PackedInts.getReaderNoHeader(fieldsIndexIn, PackedInts.Format.PACKED, packedIntsVersion, numChunks, bitsPerDocBase);

    // start pointers
    startPointers[blockCount] = fieldsIndexIn.readVLong();
    avgChunkSizes[blockCount] = fieldsIndexIn.readVLong();
    final int bitsPerStartPointer = fieldsIndexIn.readVInt();
    if (bitsPerStartPointer > 64) {
      throw new CorruptIndexException("Corrupted bitsPerStartPointer (resource=" + fieldsIndexIn + ")");
    }
    startPointersDeltas[blockCount] = PackedInts.getReaderNoHeader(fieldsIndexIn, PackedInts.Format.PACKED, packedIntsVersion, numChunks, bitsPerStartPointer);

    ++blockCount;
  }

  this.docBases = Arrays.copyOf(docBases, blockCount);
  this.startPointers = Arrays.copyOf(startPointers, blockCount);
  this.avgChunkDocs = Arrays.copyOf(avgChunkDocs, blockCount);
  this.avgChunkSizes = Arrays.copyOf(avgChunkSizes, blockCount);
  this.docBasesDeltas = Arrays.copyOf(docBasesDeltas, blockCount);
  this.startPointersDeltas = Arrays.copyOf(startPointersDeltas, blockCount);
}