How to use

readVLong

method

in

org.apache.lucene.store.IndexInput

/** Seeks the skip entry on the given level */
protected void seekChild(int level) throws IOException {
 skipStream[level].seek(lastChildPointer);
 numSkipped[level] = numSkipped[level + 1] - skipInterval[level + 1];
 skipDoc[level] = lastDoc;
 if (level > 0) {
  childPointer[level] = skipStream[level].readVLong() + skipPointer[level - 1];
 }
}

 throw new IOException("Invalid vLong detected (negative values disallowed)");
} else {
 return super.readVLong();

 @Override
 protected int readSkipData(int level, IndexInput skipStream) throws IOException {
  int delta = skipStream.readVInt();
  docPointer[level] += skipStream.readVLong();

  if (posPointer != null) {
   posPointer[level] += skipStream.readVLong();
   posBufferUpto[level] = skipStream.readVInt();

   if (payloadByteUpto != null) {
    payloadByteUpto[level] = skipStream.readVInt();
   }

   if (payPointer != null) {
    payPointer[level] += skipStream.readVLong();
   }
  }
  return delta;
 }
}

private boolean loadNextSkip(int level) throws IOException {
 // we have to skip, the target document is greater than the current
 // skip list entry        
 setLastSkipData(level);
  
 numSkipped[level] += skipInterval[level];
 // numSkipped may overflow a signed int, so compare as unsigned.
 if (Integer.compareUnsigned(numSkipped[level], docCount) > 0) {
  // this skip list is exhausted
  skipDoc[level] = Integer.MAX_VALUE;
  if (numberOfSkipLevels > level) numberOfSkipLevels = level; 
  return false;
 }
 // read next skip entry
 skipDoc[level] += readSkipData(level, skipStream[level]);
 
 if (level != 0) {
  // read the child pointer if we are not on the leaf level
  childPointer[level] = skipStream[level].readVLong() + skipPointer[level - 1];
 }
 
 return true;
}

int count = in.readVInt();
for(int i=0;i<count;i++) {
 long commitGen = in.readVLong();
 int refCount = in.readVInt();
 m.put(commitGen, refCount);

long length = skipStream[0].readVLong();

pointCount = in.readVLong();
docCount = in.readVInt();
 long lastFP = 0;
 for(int i=0;i<numLeaves;i++) {
  long delta = in.readVLong();
  leafBlockFPs[i] = lastFP + delta;
  lastFP += delta;

final long numTerms = termsIn.readVLong();
if (numTerms <= 0) {
 throw new CorruptIndexException("Illegal numTerms for field number: " + field, termsIn);
 throw new CorruptIndexException("invalid field number: " + field, termsIn);
final long sumTotalTermFreq = fieldInfo.getIndexOptions() == IndexOptions.DOCS ? -1 : termsIn.readVLong();
final long sumDocFreq = termsIn.readVLong();
final int docCount = termsIn.readVInt();
final int longsSize = termsIn.readVInt();
 throw new CorruptIndexException("invalid sumTotalTermFreq: " + sumTotalTermFreq + " sumDocFreq: " + sumDocFreq, termsIn);
final long indexStartFP = indexIn.readVLong();
FieldReader previous = fields.put(fieldInfo.name,       
                 new FieldReader(this, fieldInfo, numTerms, rootCode, sumTotalTermFreq, sumDocFreq, docCount,

startPointers[blockCount] = fieldsIndexIn.readVLong();
avgChunkSizes[blockCount] = fieldsIndexIn.readVLong();
final int bitsPerStartPointer = fieldsIndexIn.readVInt();
if (bitsPerStartPointer > 64) {

numChunks = fieldsStream.readVLong();
numDirtyChunks = fieldsStream.readVLong();
if (numDirtyChunks > numChunks) {
 throw new CorruptIndexException("invalid chunk counts: dirty=" + numDirtyChunks + ", total=" + numChunks, fieldsStream);

numChunks = vectorsStream.readVLong();
numDirtyChunks = vectorsStream.readVLong();
if (numDirtyChunks > numChunks) {
 throw new CorruptIndexException("invalid chunk counts: dirty=" + numDirtyChunks + ", total=" + numChunks, vectorsStream);

@Override
public long readVLong() throws IOException {
 if (9 <= bufferLength-bufferPosition) {
  byte b = buffer[bufferPosition++];
  long i = b & 0x7F;
  for (int shift = 7; (b & 0x80) != 0; shift += 7) {
   b = buffer[bufferPosition++];
   i |= (b & 0x7FL) << shift;
  }
  return i;
 } else {
  return super.readVLong();
 }
}

@Override
public long readVLong() throws IOException {
 if (9 <= bufferLength - bufferPosition) {
  byte b = buffer[bufferPosition++];
  long i = b & 0x7F;
  for (int shift = 7; (b & 0x80) != 0; shift += 7) {
   b = buffer[bufferPosition++];
   i |= (b & 0x7FL) << shift;
  }
  return i;
 } else {
  return super.readVLong();
 }
}

/** Seeks the skip entry on the given level */
protected void seekChild(int level) throws IOException {
 skipStream[level].seek(lastChildPointer);
 numSkipped[level] = numSkipped[level + 1] - skipInterval[level + 1];
 skipDoc[level] = lastDoc;
 if (level > 0) {
  childPointer[level] = skipStream[level].readVLong() + skipPointer[level - 1];
 }
}

/** Seeks the skip entry on the given level */
protected void seekChild(int level) throws IOException {
 skipStream[level].seek(lastChildPointer);
 numSkipped[level] = numSkipped[level + 1] - skipInterval[level + 1];
 skipDoc[level] = lastDoc;
 if (level > 0) {
  childPointer[level] = skipStream[level].readVLong() + skipPointer[level - 1];
 }
}

/** Seeks the skip entry on the given level */
protected void seekChild(int level) throws IOException {
 skipStream[level].seek(lastChildPointer);
 numSkipped[level] = numSkipped[level + 1] - skipInterval[level + 1];
 skipDoc[level] = lastDoc;
 if (level > 0) {
   childPointer[level] = skipStream[level].readVLong() + skipPointer[level - 1];
 }
}

/** Seeks the skip entry on the given level */
protected void seekChild(int level) throws IOException {
 skipStream[level].seek(lastChildPointer);
 numSkipped[level] = numSkipped[level + 1] - skipInterval[level + 1];
 skipDoc[level] = lastDoc;
 if (level > 0) {
   childPointer[level] = skipStream[level].readVLong() + skipPointer[level - 1];
 }
}

/** Seeks the skip entry on the given level */
protected void seekChild(int level) throws IOException {
 skipStream[level].seek(lastChildPointer);
 numSkipped[level] = numSkipped[level + 1] - skipInterval[level + 1];
 skipDoc[level] = lastDoc;
 if (level > 0) {
  childPointer[level] = skipStream[level].readVLong() + skipPointer[level - 1];
 }
}

@Override
public long readVLong() throws IOException {
  return delegate.readVLong();
}

private FSTEntry readFSTEntry(IndexInput meta) throws IOException {
 FSTEntry entry = new FSTEntry();
 entry.offset = meta.readLong();
 entry.numOrds = meta.readVLong();
 return entry;
}