@Override protected void processRemaining(ByteBuffer buffer) { b += buffer.remaining(); for (int i = 0; buffer.hasRemaining(); i += 8) { finalM ^= (buffer.get() & 0xFFL) << i; } }
/** * Returns the checksum of all but the first 12 bytes of {@code dex}. */ public int computeChecksum() throws IOException { Adler32 adler32 = new Adler32(); byte[] buffer = new byte[8192]; ByteBuffer data = this.data.duplicate(); // positioned ByteBuffers aren't thread safe data.limit(data.capacity()); data.position(CHECKSUM_OFFSET + SizeOf.CHECKSUM); while (data.hasRemaining()) { int count = Math.min(buffer.length, data.remaining()); data.get(buffer, 0, count); adler32.update(buffer, 0, count); } return (int) adler32.getValue(); }
/** * Get the last {@code byte} from this {@literal Buffer}. * * @return The last {@code byte}. */ public byte last() { int pos = buffer.position(); int limit = buffer.limit(); buffer.position(limit - 1); // go to right before last position byte b = buffer.get(); // get the last byte buffer.position(pos); // go back to original pos return b; }
@Override public GenericRecord parse(ByteBuffer bytes) { try { bytes.get(); // ignore first \0 byte int id = bytes.getInt(); // extract schema registry id int length = bytes.limit() - 1 - 4; int offset = bytes.position() + bytes.arrayOffset(); Schema schema = registry.getByID(id); DatumReader<GenericRecord> reader = new GenericDatumReader<>(schema); return reader.read(null, DecoderFactory.get().binaryDecoder(bytes.array(), offset, length, null)); } catch (Exception e) { throw new ParseException(e, "Fail to decode avro message!"); } }
private static <T> GenericIndexed<T> createGenericIndexedVersionOne(ByteBuffer byteBuffer, ObjectStrategy<T> strategy) { boolean allowReverseLookup = byteBuffer.get() == REVERSE_LOOKUP_ALLOWED; int size = byteBuffer.getInt(); ByteBuffer bufferToUse = byteBuffer.asReadOnlyBuffer(); bufferToUse.limit(bufferToUse.position() + size); byteBuffer.position(bufferToUse.limit()); return new GenericIndexed<>( bufferToUse, strategy, allowReverseLookup ); }
@Override public Hasher putBytes(ByteBuffer buffer) { ByteOrder bo = buffer.order(); buffer.order(ByteOrder.LITTLE_ENDIAN); while (buffer.remaining() >= 4) { putInt(buffer.getInt()); } while (buffer.hasRemaining()) { putByte(buffer.get()); } buffer.order(bo); return this; }
@SuppressWarnings("ByteBufferBackingArray") @NonNull public static byte[] toBytes(@NonNull ByteBuffer byteBuffer) { final byte[] result; SafeArray safeArray = getSafeArray(byteBuffer); if (safeArray != null && safeArray.offset == 0 && safeArray.limit == safeArray.data.length) { result = byteBuffer.array(); } else { ByteBuffer toCopy = byteBuffer.asReadOnlyBuffer(); result = new byte[toCopy.limit()]; toCopy.position(0); toCopy.get(result); } return result; }
/** * Try to read an EOL incrementing the buffer position if successful. * @return whether an EOL was consumed */ private boolean tryConsumeEndOfLine(ByteBuffer byteBuffer) { if (byteBuffer.remaining() > 0) { byte b = byteBuffer.get(); if (b == '\n') { return true; } else if (b == '\r') { if (byteBuffer.remaining() > 0 && byteBuffer.get() == '\n') { return true; } else { throw new StompConversionException("'\\r' must be followed by '\\n'"); } } // Explicit cast for compatibility with covariant return type on JDK 9's ByteBuffer ((Buffer) byteBuffer).position(byteBuffer.position() - 1); } return false; }
@Override public int read() { if (!byteBuffer.hasRemaining()) { return -1; } return byteBuffer.get(); }
public static byte[] readLengthPrefixedByteArray(ByteBuffer buf) throws IOException { int len = buf.getInt(); if (len < 0) { throw new IOException("Negative length"); } else if (len > buf.remaining()) { throw new IOException("Underflow while reading length-prefixed value. Length: " + len + ", available: " + buf.remaining()); } byte[] result = new byte[len]; buf.get(result); return result; }
@Override public Object get(ByteBuffer buf, int position) { ByteBuffer dataCopyBuffer = ByteBuffer.allocate(HyperLogLogCollector.getLatestNumBytesForDenseStorage()); ByteBuffer mutationBuffer = buf.duplicate(); mutationBuffer.position(position); mutationBuffer.get(dataCopyBuffer.array()); return HyperLogLogCollector.makeCollector(dataCopyBuffer); }
ResTable_type(ByteBuffer buf, int offset) { super(buf, offset); header = new ResChunk_header(buf, offset); id = buf.get(offset + ResChunk_header.SIZEOF); flags = buf.get(offset + ResChunk_header.SIZEOF + 1); reserved = buf.getShort(offset + ResChunk_header.SIZEOF + 2); entryCount = buf.getInt(offset + ResChunk_header.SIZEOF + 4); entriesStart = buf.getInt(offset + ResChunk_header.SIZEOF + 8); buf.position(offset + ResChunk_header.SIZEOF + 12); config = ResTable_config.createConfig(buf); }
public DeltaLongEncodingReader(ByteBuffer fromBuffer) { this.buffer = fromBuffer.asReadOnlyBuffer(); byte version = buffer.get(); if (version == CompressionFactory.DELTA_ENCODING_VERSION) { base = buffer.getLong(); bitsPerValue = buffer.getInt(); fromBuffer.position(buffer.position()); deserializer = VSizeLongSerde.getDeserializer(bitsPerValue, buffer, buffer.position()); } else { throw new IAE("Unknown version[%s]", version); } }
public static final Pair<Bucket, byte[]> fromGroupKey(byte[] keyBytes) { ByteBuffer buf = ByteBuffer.wrap(keyBytes); Bucket bucket = new Bucket(buf.getInt(), DateTimes.utc(buf.getLong()), buf.getInt()); byte[] bytesLeft = new byte[buf.remaining()]; buf.get(bytesLeft); return Pair.of(bucket, bytesLeft); }
public ImmutableRTree(ByteBuffer data, BitmapFactory bitmapFactory) { final int initPosition = data.position(); Preconditions.checkArgument(data.get(initPosition) == VERSION, "Mismatching versions"); this.numDims = data.getInt(1 + initPosition) & 0x7FFF; this.data = data; this.root = new ImmutableNode(numDims, initPosition, 1 + Integer.BYTES, data, bitmapFactory); }