* Compatibility:
* This class has been used in products that have shipped to customers, and is needed to
* decode legacy data. Do not modify this class in ways that will break compatibility.
*
* @lucene.experimental
*/
public class Vint8 {
/**
* Because Java lacks call-by-reference, this class boxes the decoding position, which
* is initially set by the caller, and returned after decoding, incremented by the number
* of bytes processed.
*/
public static class Position {
/**
* Creates a position value set to zero.
*/
public Position() {
// The initial position is zero by default.
}
/**
* Creates a position set to {@code initialPosition}.
* @param initialPosition The starting decoding position in the source buffer.
*/
public Position(int initialPosition) {
this.pos = initialPosition;
}
/**
* The value passed by reference.
*/
public int pos;
}
/**
* Returns the number of bytes needed to encode {@code number}.
* @param number The number whose encoded length is needed.
* @return The number of bytes needed to encode {@code number}.
*/
public static int bytesNeeded(int number) {
if ((number & ~0x7F) == 0) {
return 1;
} else if ((number & ~0x3FFF) == 0) {
return 2;
} else if ((number & ~0x1FFFFF) == 0) {
return 3;
} else if ((number & ~0xFFFFFFF) == 0) {
return 4;
} else {
return 5;
}
}
/**
* The maximum number of bytes needed to encode a number using {@code Vint8}.
*/
public static final int MAXIMUM_BYTES_NEEDED = 5;
/**
* Encodes {@code number} to {@code out}.
* @param number The value to be written in encoded form, to {@code out}.
* @param out The output stream receiving the encoded bytes.
* @exception IOException If there is a problem writing to {@code out}.
*/
public static void encode(int number, OutputStream out) throws IOException {
if ((number & ~0x7F) == 0) {
out.write(number);
} else if ((number & ~0x3FFF) == 0) {
out.write(0x80 | (number >> 7));
out.write(0x7F & number);
} else if ((number & ~0x1FFFFF) == 0) {
out.write(0x80 | (number >> 14));
out.write(0x80 | (number >> 7));
out.write(0x7F & number);
} else if ((number & ~0xFFFFFFF) == 0) {
out.write(0x80 | (number >> 21));
out.write(0x80 | (number >> 14));
out.write(0x80 | (number >> 7));
out.write(0x7F & number);
} else {
out.write(0x80 | (number >> 28));
out.write(0x80 | (number >> 21));
out.write(0x80 | (number >> 14));
out.write(0x80 | (number >> 7));
out.write(0x7F & number);
}
}
/**
* Encodes {@code number} into {@code dest}, starting at offset {@code start} from
* the beginning of the array. This method assumes {@code dest} is large enough to
* hold the required number of bytes.
* @param number The number to be encoded.
* @param dest The destination array.
* @param start The starting offset in the array.
* @return The number of bytes used in the array.
*/
public static int encode(int number, byte[] dest, int start) {
if ((number & ~0x7F) == 0) {
dest[start] = (byte) number;
return 1;
} else if ((number & ~0x3FFF) == 0) {
dest[start] = (byte) (0x80 | ((number & 0x3F80) >> 7));
dest[start + 1] = (byte) (number & 0x7F);
return 2;
} else if ((number & ~0x1FFFFF) == 0) {
dest[start] = (byte) (0x80 | ((number & 0x1FC000) >> 14));
dest[start + 1] = (byte) (0x80 | ((number & 0x3F80) >> 7));
dest[start + 2] = (byte) (number & 0x7F);
return 3;
} else if ((number & ~0xFFFFFFF) == 0) {
dest[start] = (byte) (0x80 | ((number & 0xFE00000) >> 21));
dest[start + 1] = (byte) (0x80 | ((number & 0x1FC000) >> 14));
dest[start + 2] = (byte) (0x80 | ((number & 0x3F80) >> 7));
dest[start + 3] = (byte) (number & 0x7F);
return 4;
} else {
dest[start] = (byte) (0x80 | ((number & 0xF0000000) >> 28));
dest[start + 1] = (byte) (0x80 | ((number & 0xFE00000) >> 21));
dest[start + 2] = (byte) (0x80 | ((number & 0x1FC000) >> 14));
dest[start + 3] = (byte) (0x80 | ((number & 0x3F80) >> 7));
dest[start + 4] = (byte) (number & 0x7F);
return 5;
}
}
/**
* Decodes a 32-bit integer from {@code bytes}, beginning at offset {@code pos.pos}.
* The decoded value is returned, and {@code pos.pos} is incremented by the number of
* bytes processed.
* @param bytes The byte array containing an encoded value.
* @param pos On entry, the starting position in the array; on return, one greater
* than the position of the last byte decoded in the call.
* @return The decoded value.
*/
public static int decode(byte[] bytes, Position pos) {
int value = 0;
while (true) {
byte first = bytes[pos.pos];
++pos.pos;
value |= first & 0x7F;
if ((first & 0x80) == 0) {
return value;
}
value <<= 7;
}
}
/**
* Decodes a 32-bit integer from bytes read from {@code in}. Bytes are read,
* one at a time, from {@code in}, and it is assumed they represent a 32-bit
* integer encoded using this class's encoding scheme. The decoded value is
* returned.
* @param in The input stream containing the encoded bytes.
* @return The decoded value.
* @exception EOFException If the stream ends before a value has been decoded.
*/
public static int decode(InputStream in) throws IOException {
int value = 0;
while (true) {
int first = in.read();
if (first < 0) {
throw new EOFException();
}
value |= first & 0x7F;
if ((first & 0x80) == 0) {
return value;
}
value <<= 7;
}
}
/**
* The default ctor is made private because all methods of this class are static.
*/
private Vint8() {
// Just making it impossible to instantiate.
}
}