Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.storemate.store.util;
  
  import java.util.Arrays;

Simple utility class for decoding semi-structured data.

All multi-byte values use Big-Endian byte ordering (MSB first); VInts are assumed positive, last byte indicated by set sign-bit.

 
 public class BytesToStuff
 {
     private final byte[] _data;
     private final int _end;
 
     private int _ptr;
     
     public BytesToStuff(byte[] data) {
         this(data, 0, data.length);
     }
 
     public BytesToStuff(byte[] dataint offsetint len)
     {
          = data;
          = offset;
          = offset+len;
     }
 
     /*
     /**********************************************************************
     /* Public API
     /**********************************************************************
      */
     
     public void skip(int count) {
         _verifyBounds(count);
          += count;
     }
     
     public int left() {
         return  - ;
     }
     
     public int offset() {
         return ;
     }
     
     public byte nextByte()
     {
         if ( >= ) {
             _reportBounds(1);
         }
         return [++];
     }
 
     public byte[] nextBytes(int amount)
     {
         _verifyBounds(amount);
         final int ptr = ;
          += amount;
         return Arrays.copyOfRange(ptrptr+amount);
     }
     
     public int nextInt()
     {
         _verifyBounds(4);
         return _nextInt();
     }
     
     public long nextLong()
     {
         _verifyBounds(8);
         long l1 = _nextInt();
         long l2 = _nextInt();
         // this may look silly, but the thing is to avoid sign-extension...
         return (l1 << 32) | ((l2 << 32) >>> 32);
     }
 
     public int nextVInt()
     {
         int bytesDone = 0;
         int ptr = ;
         int value = 0;
         
         while (true) {
             ++bytesDone;
             if (ptr >= ) {
                 _reportBounds(bytesDone);
             }
             value = (value << 7);
             int i = [ptr++];
             if (i < 0) { // last one
                 i &= 0x7F;
                 value += i;
                 break;
             }
             value += i;
         }
          = ptr;
        if (bytesDone > .) { // sanity check
            throw new IllegalStateException("Corrupt VInt, shouldn't have more than 5 bytes, had: "+bytesDone);
        }
        return value;
    }
    
    public long nextVLong()
    {
        int bytesDone = 0;
        int ptr = ;
        long value = 0L;
        
        while (true) {
            ++bytesDone;
            if (ptr >= ) {
                _reportBounds(bytesDone);
            }
            value = (value << 7);
            int i = [ptr++];
            if (i < 0) { // last one
                i &= 0x7F;
                value += i;
                break;
            }
            value += i;
        }
         = ptr;
        if (bytesDone > .) { // only 9 (63 bits) because we don't do negative numbers
            throw new IllegalStateException("Corrupt VLong, shouldn't have more than 9 bytes, had: "+bytesDone);
        }
        return value;
    }
    /*
    /**********************************************************************
    /* Internal methods
    /**********************************************************************
     */
    
    private int _nextInt()
    {
        int ptr = ;
        int i = ([ptr++] << 24);
        i |= ([ptr++] & 0xFF) << 16;
        i |= ([ptr++] & 0xFF) << 8;
        i |= ([ptr++] & 0xFF);
         = ptr;
        return i;
    }
    protected void _verifyBounds(int bytesNeeded)
    {
        if (( + bytesNeeded) > ) {
            _reportBounds(bytesNeeded);
        }
    }
    
    protected void _reportBounds(int bytesNeeded)
    {
        int left =  - ;
        throw new IllegalStateException("Unexpected end of data: need "+bytesNeeded
                +"; only have "+left+" (offset "++")");
    }
New to GrepCode? Check out our FAQ X