| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| package streamer; |
| |
| import java.nio.charset.Charset; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * This class represents a slice in a buffer. |
| */ |
| public class ByteBuffer { |
| |
| public static final String SEQUENCE_NUMBER = "seq"; |
| |
| public byte data[]; |
| public int offset = 0; |
| public int length = 0; |
| public int cursor = 0; |
| |
| private int refCount = 1; |
| |
| private Order order; |
| |
| /** |
| * Create buffer of size no less than length. Buffer can be a bit larger than |
| * length. Offset also can be set to non-zero value to leave some place for |
| * future headers. |
| */ |
| public ByteBuffer(int minLength) { |
| // Get buffer of acceptable size from buffer pool |
| data = BufferPool.allocateNewBuffer(minLength); |
| offset = 0; |
| length = minLength; |
| } |
| |
| public ByteBuffer(byte data[]) { |
| if (data == null) |
| throw new NullPointerException("Data must be non-null."); |
| |
| this.data = data; |
| offset = 0; |
| length = data.length; |
| } |
| |
| public ByteBuffer(byte[] data, int offset, int length) { |
| if (data == null) |
| throw new NullPointerException("Data must be non-null."); |
| |
| this.data = data; |
| this.offset = offset; |
| this.length = length; |
| } |
| |
| /** |
| * Create byte buffer of requested size with some space reserved for future |
| * headers. |
| */ |
| public ByteBuffer(int minLength, boolean reserveSpaceForHeader) { |
| // Get buffer of acceptable size from buffer pool |
| data = BufferPool.allocateNewBuffer(128 + minLength); |
| offset = 128; // 100 bytes should be enough for headers |
| length = minLength; |
| } |
| |
| /** |
| * Create empty buffer with given order only. |
| */ |
| public ByteBuffer(Order order) { |
| this.order = order; |
| } |
| |
| public void setOrder(Order order) { |
| this.order = order; |
| } |
| |
| public Order getOrder() { |
| return order; |
| } |
| |
| @Override |
| public String toString() { |
| return toString(length); |
| } |
| |
| /** |
| * Return string representation of this byte buffer. |
| * |
| * @param maxLength |
| * number of bytes to show in string |
| */ |
| public String toString(int maxLength) { |
| return "ByteRange(){offset=" + offset + ", length=" + length + ", cursor=" + cursor + ", data=" + ((data == null) ? "null" : toHexString(maxLength)) |
| + ((metadata == null || metadata.size() == 0) ? "" : ", metadata=" + metadata) + "}"; |
| } |
| |
| /** |
| * Return string representation of this byte buffer as hexadecimal numbers, |
| * e.g. "[0x01, 0x02]". |
| * |
| * @param maxLength |
| * number of bytes to show in string |
| */ |
| public String toHexString(int maxLength) { |
| StringBuilder builder = new StringBuilder(maxLength * 6); |
| builder.append('['); |
| for (int i = 0; i < maxLength && i < length; i++) { |
| if (i > 0) |
| builder.append(", "); |
| int b = data[offset + i] & 0xff; |
| builder.append("0x" + ((b < 16) ? "0" : "") + Integer.toString(b, 16)); |
| } |
| builder.append(']'); |
| return builder.toString(); |
| } |
| |
| /** |
| * Return string representation of this byte buffer as hexadecimal numbers, |
| * e.g. "01 02". |
| * |
| * @param maxLength |
| * number of bytes to show in string |
| */ |
| public String toPlainHexString(int maxLength) { |
| StringBuilder builder = new StringBuilder(maxLength * 3); |
| for (int i = 0; i < maxLength && i < length; i++) { |
| if (i > 0) |
| builder.append(" "); |
| int b = data[offset + i] & 0xff; |
| builder.append(String.format("%02x", b)); |
| } |
| return builder.toString(); |
| } |
| |
| /** |
| * Return string representation of this byte buffer as dump, e.g. |
| * "0000 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 .................". |
| * |
| * @param maxLength |
| * number of bytes to show in string |
| */ |
| public String dump() { |
| StringBuilder builder = new StringBuilder(length * 4); |
| int i = addBytesToBuilder(builder); |
| int end = i - 1; |
| if (end % 16 != 15) { |
| int begin = end & ~0xf; |
| for (int j = 0; j < (15 - (end % 16)); j++) { |
| builder.append(" "); |
| } |
| builder.append(' '); |
| builder.append(toASCIIString(begin, end)); |
| builder.append('\n'); |
| } |
| return builder.toString(); |
| } |
| |
| protected int addBytesToBuilder(StringBuilder builder) { |
| int i = 0; |
| for (; i < length; i++) { |
| if (i % 16 == 0) { |
| builder.append(String.format("%04x", i)); |
| } |
| |
| builder.append(' '); |
| int b = data[offset + i] & 0xff; |
| builder.append(String.format("%02x", b)); |
| |
| if (i % 16 == 15) { |
| builder.append(' '); |
| builder.append(toASCIIString(i - 15, i)); |
| builder.append('\n'); |
| } |
| } |
| return i; |
| } |
| |
| private String toASCIIString(int start, int finish) { |
| StringBuffer sb = new StringBuffer(16); |
| for (int i = start; i <= finish; i++) { |
| char ch = (char)data[offset + i]; |
| if (ch < ' ' || ch >= 0x7f) { |
| sb.append('.'); |
| } else { |
| sb.append(ch); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Return string representation of this byte buffer as hexadecimal numbers, |
| * e.g. "01 02". |
| */ |
| public String toPlainHexString() { |
| return toPlainHexString(length); |
| } |
| |
| public void extend(int newLength) { |
| if (data.length < newLength) |
| Arrays.copyOf(data, newLength); |
| } |
| |
| public void ref() { |
| refCount++; |
| } |
| |
| public void unref() { |
| refCount--; |
| |
| if (refCount == 0) { |
| // Return buffer to buffer pool |
| BufferPool.recycleBuffer(data); |
| |
| data = null; |
| } |
| |
| } |
| |
| public boolean isSoleOwner() { |
| return refCount == 1; |
| } |
| |
| /** |
| * Create shared lightweight copy of part of this buffer. |
| */ |
| public ByteBuffer slice(int offset, int length, boolean copyMetadata) { |
| ref(); |
| |
| if (this.length < (offset + length)) |
| throw new RuntimeException("Length of region is larger that length of this buffer. Buffer length: " + this.length + ", offset: " + offset + ", new region length: " |
| + length + "."); |
| |
| ByteBuffer slice = new ByteBuffer(data, this.offset + offset, length); |
| |
| if (copyMetadata && metadata != null) |
| slice.metadata = new HashMap<String, Object>(metadata); |
| |
| return slice; |
| } |
| |
| private Map<String, Object> metadata = null; |
| |
| public Object putMetadata(String key, Object value) { |
| if (metadata == null) |
| metadata = new HashMap<String, Object>(); |
| return metadata.put(key, value); |
| } |
| |
| public Object getMetadata(String key) { |
| return (metadata != null) ? metadata.get(key) : null; |
| } |
| |
| /** |
| * Create new buffer, which holds data from both buffers. Expensive operation. |
| * |
| * @TODO if only one reference to this ByteBuffer exists, then extend this |
| * buffer instead of creating new buffer |
| * @TODO support list of buffers to avoid expensive joins until absolute |
| * necessary |
| */ |
| public ByteBuffer join(ByteBuffer buf) { |
| // Extend byte array for new data |
| int newLength = length + buf.length; |
| byte newData[] = new byte[newLength]; |
| |
| // Copy data from our buffer |
| System.arraycopy(data, offset, newData, 0, length); |
| |
| // Copy data from other buffer |
| System.arraycopy(buf.data, buf.offset, newData, length, buf.length); |
| |
| ByteBuffer newBuf = new ByteBuffer(newData); |
| |
| // Copy our (older) metadata to new buffer, because handler might store some |
| // metadata in buffer, which is pushed back. |
| if (metadata != null) |
| newBuf.metadata = new HashMap<String, Object>(metadata); |
| |
| return newBuf; |
| } |
| |
| /** |
| * Copy used portion of buffer to new byte array. Expensive operation. |
| */ |
| public byte[] toByteArray() { |
| return Arrays.copyOfRange(data, offset, offset + length); |
| } |
| |
| public short[] toShortArray() { |
| if (length % 2 != 0) |
| throw new ArrayIndexOutOfBoundsException("Length of byte array must be dividable by 2 without remainder. Array length: " + length + ", remainder: " + (length % 2) |
| + "."); |
| |
| short[] buf = new short[length / 2]; |
| |
| for (int i = 0, j = offset; i < buf.length; i++, j += 2) { |
| buf[i] = (short)((data[j + 0] & 0xFF) | ((data[j + 1] & 0xFF) << 8)); |
| } |
| return buf; |
| } |
| |
| /** |
| * Return array of int's in little endian order. |
| */ |
| public int[] toIntLEArray() { |
| if (length % 4 != 0) |
| throw new ArrayIndexOutOfBoundsException("Length of byte array must be dividable by 4 without remainder. Array length: " + length + ", remainder: " + (length % 4) |
| + "."); |
| |
| int[] buf = new int[length / 4]; |
| |
| for (int i = 0, j = offset; i < buf.length; i++, j += 4) { |
| buf[i] = (data[j + 0] & 0xFF) | ((data[j + 1] & 0xFF) << 8) | ((data[j + 2] & 0xFF) << 16) | ((data[j + 3] & 0xFF) << 24); |
| } |
| return buf; |
| } |
| |
| /** |
| * Return array of int's in little endian order, but use only 3 bytes per int |
| * (3RGB). |
| */ |
| public int[] toInt3LEArray() { |
| if (length % 3 != 0) |
| throw new ArrayIndexOutOfBoundsException("Length of byte array must be dividable by 3 without remainder. Array length: " + length + ", remainder: " + (length % 3) |
| + "."); |
| |
| int[] buf = new int[length / 3]; |
| |
| for (int i = 0, j = offset; i < buf.length; i++, j += 3) { |
| buf[i] = (data[j + 0] & 0xFF) | ((data[j + 1] & 0xFF) << 8) | ((data[j + 2] & 0xFF) << 16); |
| } |
| return buf; |
| } |
| |
| /** |
| * Helper method for test cases to convert array of byte arrays to array of |
| * byte buffers. |
| */ |
| public static ByteBuffer[] convertByteArraysToByteBuffers(byte[]... bas) { |
| ByteBuffer bufs[] = new ByteBuffer[bas.length]; |
| |
| int i = 0; |
| for (byte[] ba : bas) { |
| bufs[i++] = new ByteBuffer(ba); |
| } |
| return bufs; |
| } |
| |
| /** |
| * Read signed int in network order. Cursor is advanced by 4. |
| */ |
| public int readSignedInt() { |
| if (cursor + 4 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 4 bytes from this buffer: " + this + "."); |
| |
| int result = (((data[offset + cursor] & 0xff) << 24) + ((data[offset + cursor + 1] & 0xff) << 16) + ((data[offset + cursor + 2] & 0xff) << 8) + (data[offset + cursor + 3] & 0xff)); |
| cursor += 4; |
| return result; |
| } |
| |
| /** |
| * Read signed int in little endian order. Cursor is advanced by 4. |
| */ |
| public int readSignedIntLE() { |
| if (cursor + 4 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 4 bytes from this buffer: " + this + "."); |
| |
| int result = (((data[offset + cursor + 3] & 0xff) << 24) + ((data[offset + cursor + 2] & 0xff) << 16) + ((data[offset + cursor + 1] & 0xff) << 8) + (data[offset + cursor] & 0xff)); |
| cursor += 4; |
| return result; |
| } |
| |
| /** |
| * Read unsigned int in little endian order. Cursor is advanced by 4. |
| */ |
| public long readUnsignedIntLE() { |
| if (cursor + 4 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 4 bytes from this buffer: " + this + "."); |
| |
| long result = (((long)(data[offset + cursor + 3] & 0xff) << 24) + ((long)(data[offset + cursor + 2] & 0xff) << 16) + ((long)(data[offset + cursor + 1] & 0xff) << 8) + (data[offset |
| + cursor + 0] & 0xff)); |
| cursor += 4; |
| return result; |
| } |
| |
| /** |
| * Read unsigned int in network order. Cursor is advanced by 4. |
| */ |
| public long readUnsignedInt() { |
| if (cursor + 4 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 4 bytes from this buffer: " + this + "."); |
| |
| byte value1 = data[offset + cursor + 0]; |
| byte value2 = data[offset + cursor + 1]; |
| byte value3 = data[offset + cursor + 2]; |
| byte value4 = data[offset + cursor + 3]; |
| long result = calculateUnsignedInt(value1, value2, value3, value4); |
| cursor += 4; |
| return result; |
| } |
| |
| protected static long calculateUnsignedInt(byte value1, byte value2, byte value3, byte value4) { |
| return (((long)calculateUnsignedByte(value1)) << 24) |
| + (((long)calculateUnsignedByte(value2)) << 16) |
| + (((long)calculateUnsignedByte(value3)) << 8) |
| + calculateUnsignedByte(value4); |
| } |
| |
| /** |
| * Read signed int in variable length format. Top most bit of each byte |
| * indicates that next byte contains additional bits. Cursor is advanced by |
| * 1-5 bytes. |
| */ |
| public int readVariableSignedIntLE() { |
| int result = 0; |
| |
| for (int shift = 0; shift < 32; shift += 7) { |
| int b = readUnsignedByte(); |
| result |= (b & 0x7f) << shift; |
| if ((b & 0x80) == 0) |
| break; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Read unsigned int in network order in variable length format. Cursor is |
| * advanced by 1 to 4 bytes. |
| * |
| * Two most significant bits of first byte indicates length of field: 0x00 - 1 |
| * byte, 0x40 - 2 bytes, 0x80 - 3 bytes, 0xc0 - 4 bytes. |
| * |
| * @see http://msdn.microsoft.com/en-us/library/cc241614.aspx |
| */ |
| public int readEncodedUnsignedInt() { |
| int firstByte = readUnsignedByte(); |
| int result; |
| switch (firstByte & 0xc0) { |
| default: |
| case 0x00: |
| result = firstByte & 0x3f; |
| break; |
| case 0x40: |
| result = (firstByte & 0x3f << 8) | readUnsignedByte(); |
| break; |
| case 0x80: |
| result = (((firstByte & 0x3f << 8) | readUnsignedByte()) << 8) | readUnsignedByte(); |
| break; |
| case 0xc0: |
| result = ((((firstByte & 0x3f << 8) | readUnsignedByte()) << 8) | readUnsignedByte() << 8) | readUnsignedByte(); |
| break; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Read unsigned byte. Cursor is advanced by 1. |
| */ |
| public int readUnsignedByte() { |
| if (cursor + 1 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 1 byte from this buffer: " + this + "."); |
| |
| byte value = data[offset + cursor]; |
| int b = calculateUnsignedByte(value); |
| cursor += 1; |
| return b; |
| } |
| |
| protected static int calculateUnsignedByte(byte value) { |
| return value & 0xff; |
| } |
| |
| /** |
| * Read signed byte. Cursor is advanced by 1. |
| */ |
| public byte readSignedByte() { |
| if (cursor + 1 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 1 byte from this buffer: " + this + "."); |
| |
| byte b = data[offset + cursor]; |
| cursor += 1; |
| return b; |
| } |
| |
| /** |
| * Read unsigned short in network order. Cursor is advanced by 2. |
| */ |
| public int readUnsignedShort() { |
| if (cursor + 2 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 2 bytes from this buffer: " + this + "."); |
| |
| byte value1 = data[offset + cursor]; |
| byte value2 = data[offset + cursor + 1]; |
| int result = calculateUnsignedShort(value1, value2); |
| cursor += 2; |
| return result; |
| } |
| |
| protected static int calculateUnsignedShort(byte value1, byte value2) { |
| return (calculateUnsignedByte(value1) << 8) | calculateUnsignedByte(value2); |
| } |
| |
| /** |
| * Read signed short in little endian order. Cursor is advanced by 2. |
| */ |
| public short readSignedShortLE() { |
| if (cursor + 2 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 2 bytes from this buffer: " + this + "."); |
| |
| short result = (short)(((data[offset + cursor + 1] & 0xff) << 8) | (data[offset + cursor] & 0xff)); |
| cursor += 2; |
| return result; |
| } |
| |
| /** |
| * Read signed short in network order. Cursor is advanced by 2. |
| */ |
| public short readSignedShort() { |
| if (cursor + 2 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 2 bytes from this buffer: " + this + "."); |
| |
| byte value1 = data[offset + cursor + 0]; |
| byte value2 = data[offset + cursor + 1]; |
| short result = calculateSignedShort(value1, value2); |
| cursor += 2; |
| return result; |
| } |
| |
| protected static short calculateSignedShort(byte value1, byte value2) { |
| return (short)calculateUnsignedShort(value1, value2); |
| } |
| |
| /** |
| * Read unsigned short in network order in variable length format. Cursor is |
| * advanced by 1 or 2 bytes. |
| * |
| * Most significant bit of first byte indicates length of field: 0 - 1 byte, 1 |
| * - 2 bytes. |
| */ |
| public int readVariableUnsignedShort() { |
| int firstByte = readUnsignedByte(); |
| |
| int result; |
| if ((firstByte & 0x80) == 0) { |
| result = firstByte & 0x7f; |
| } else { |
| int secondByte = readUnsignedByte(); |
| result = (((firstByte & 0x7f) << 8) | secondByte); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Read integer in BER format. |
| * |
| * Most significant bit of first byte indicates type of date in first byte: if |
| * 0, then byte contains length (up to 7f), if 1, then byte contains number of |
| * following bytes with value in network order. Value 0x80 means unlimited |
| * length, which ends with two zero bytes (0x00 0x00) sequence. |
| * |
| * If -1 is returned by this method, then caller must seek two consecutive |
| * zeroes in buffer and consume all that data from buffer, including these two |
| * zeroes, but caller should not parse these two zeroes. |
| * |
| * @return length or -1, for unlimited length |
| */ |
| public long readBerLength() { |
| int firstByte = readUnsignedByte(); |
| |
| long result; |
| if ((firstByte & 0x80) == 0) { |
| result = firstByte & 0x7f; |
| } else { |
| int intLength = firstByte & 0x7f; |
| if (intLength != 0) |
| result = readUnsignedVarInt(intLength); |
| else |
| return -1; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Read integer in BER format. |
| * |
| * Most significant bit of first byte indicates type of date in first byte: if |
| * 0, then byte contains length (up to 7f), if 1, then byte contains number of |
| * following bytes with value in network order. |
| */ |
| public void writeBerLength(long length) { |
| if (length < 0) |
| throw new RuntimeException("Length cannot be less than zero: " + length + ". Data: " + this + "."); |
| |
| if (length < 0x80) { |
| writeByte((int)length); |
| } else { |
| if (length < 0xff) { |
| writeByte(0x81); |
| writeByte((int)length); |
| } else if (length <= 0xffFF) { |
| writeByte(0x82); |
| writeShort((int)length); |
| } else if (length <= 0xffFFff) { |
| writeByte(0x83); |
| writeByte((int)(length >> 16)); |
| writeShort((int)length); |
| } else if (length <= 0xffFFffFFL) { |
| writeByte(0x84); |
| writeInt((int)length); |
| } else if (length <= 0xffFFffFFffL) { |
| writeByte(0x85); |
| writeByte((int)(length >> 32)); |
| writeInt((int)length); |
| } else if (length <= 0xffFFffFFffFFL) { |
| writeByte(0x86); |
| writeShort((int)(length >> 32)); |
| writeInt((int)length); |
| } else if (length <= 0xffFFffFFffFFffL) { |
| writeByte(0x87); |
| writeByte((int)(length >> (32 + 16))); |
| writeShort((int)(length >> 32)); |
| writeInt((int)length); |
| } else { |
| writeByte(0x88); |
| writeInt((int)(length >> 32)); |
| writeInt((int)length); |
| } |
| } |
| |
| } |
| |
| /** |
| * Read signed variable length integers in network order. |
| * |
| * @param len |
| * length of integer |
| */ |
| public long readSignedVarInt(int len) { |
| long value = 0; |
| switch (len) { |
| case 0: |
| value = 0; |
| break; |
| case 1: |
| value = readSignedByte(); |
| break; |
| case 2: |
| value = readSignedShort(); |
| break; |
| case 3: |
| value = (readSignedByte() << 16) | readUnsignedShort(); |
| break; |
| case 4: |
| value = readSignedInt(); |
| break; |
| case 5: |
| value = readSignedByte() | readUnsignedInt(); |
| break; |
| case 6: |
| value = readSignedShort() | readUnsignedInt(); |
| break; |
| case 7: |
| value = (readSignedByte() << 24) | readUnsignedShort() | readUnsignedInt(); |
| break; |
| case 8: |
| value = readSignedLong(); |
| break; |
| default: |
| throw new RuntimeException("Cannot read integers which are more than 8 bytes long. Length: " + len + ". Data: " + this + "."); |
| } |
| |
| return value; |
| } |
| |
| /** |
| * Read unsigned variable length integers in network order. Values, which are |
| * larger than 0x7FffFFffFFffFFff cannot be parsed by this method. |
| */ |
| public long readUnsignedVarInt(int len) { |
| long value = 0; |
| switch (len) { |
| case 0: |
| value = 0; |
| break; |
| case 1: |
| value = readUnsignedByte(); |
| break; |
| case 2: |
| value = readUnsignedShort(); |
| break; |
| case 3: |
| value = (readUnsignedByte() << 16) | readUnsignedShort(); |
| break; |
| case 4: |
| value = readUnsignedInt(); |
| break; |
| case 5: |
| value = readUnsignedByte() | readUnsignedInt(); |
| break; |
| case 6: |
| value = readUnsignedShort() | readUnsignedInt(); |
| break; |
| case 7: |
| value = (readUnsignedByte() << 16) | readUnsignedShort() | readUnsignedInt(); |
| break; |
| case 8: |
| value = readSignedLong(); |
| if (value < 0) |
| throw new RuntimeException("Cannot read 64 bit integers which are larger than 0x7FffFFffFFffFFff, because of lack of unsinged long type in Java. Value: " + value |
| + ". Data: " + this + "."); |
| break; |
| default: |
| throw new RuntimeException("Cannot read integers which are more than 8 bytes long. Length: " + len + ". Data: " + this + "."); |
| } |
| |
| return value; |
| } |
| |
| /** |
| * Read unsigned short in little endian order. Cursor is advanced by 2. |
| */ |
| public int readUnsignedShortLE() { |
| if (cursor + 2 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read 2 bytes from this buffer: " + this + "."); |
| |
| int result = (((data[offset + cursor + 1] & 0xff) << 8) | (data[offset + cursor] & 0xff)); |
| cursor += 2; |
| return result; |
| } |
| |
| /** |
| * Read unsigned short in network order in variable length format. Cursor is |
| * advanced by 1 or 2 bytes. |
| * |
| * Most significant bit of first byte indicates length of field: 0x00 - 1 |
| * byte, 0x80 - 2 bytes. |
| * |
| * @see http://msdn.microsoft.com/en-us/library/cc241612.aspx |
| */ |
| public int readEncodedUnsignedShort() { |
| int firstByte = readUnsignedByte(); |
| |
| int result; |
| if ((firstByte & 0x80) == 0) |
| result = firstByte & 0x7f; |
| else { |
| int secondByte = readUnsignedByte(); |
| result = (((firstByte & 0x7f) << 8) | secondByte); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Read signed short in network order in variable length format. Cursor is |
| * advanced by 1 or 2 bytes. |
| * |
| * Most significant bit of first byte indicates length of field: 0x00 - 1 |
| * byte, 0x80 - 2 bytes. Second most significant bit indicates is value |
| * positive or negative. |
| * |
| * @see http://msdn.microsoft.com/en-us/library/cc241613.aspx |
| */ |
| public int readEncodedSignedShort() { |
| int firstByte = readUnsignedByte(); |
| |
| int result; |
| if ((firstByte & 0x80) == 0) |
| result = firstByte & 0x3f; |
| else { |
| int secondByte = readUnsignedByte(); |
| result = (((firstByte & 0x3f) << 8) | secondByte); |
| } |
| |
| if ((firstByte & 0x40) > 0) |
| return -result; |
| else |
| return result; |
| } |
| |
| /** |
| * Read signed long in little endian order. Cursor is advanced by 8 bytes. |
| */ |
| public long readSignedLongLE() { |
| return ((readSignedIntLE()) & 0xffFFffFFL) | (((long)readSignedIntLE()) << 32); |
| } |
| |
| /** |
| * Read signed long in network order. Cursor is advanced by 8 bytes. |
| */ |
| public long readSignedLong() { |
| return (((long)readSignedInt()) << 32) | ((readSignedInt()) & 0xffFFffFFL); |
| } |
| |
| /** |
| * Read string from buffer. Cursor is advanced by string length. |
| */ |
| public String readString(int length, Charset charset) { |
| if (cursor + length > this.length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read " + length + " bytes from this buffer: " + this + "."); |
| |
| String string = new String(data, offset + cursor, length, charset); |
| cursor += length; |
| return string; |
| } |
| |
| /** |
| * Read string with '\0' character at end. |
| */ |
| public String readVariableString(Charset charset) { |
| |
| int start = cursor; |
| |
| // Find end of string |
| while (readUnsignedByte() != 0) { |
| } |
| |
| String string = new String(data, offset + start, cursor - start - 1, charset); |
| |
| return string; |
| } |
| |
| /** |
| * Read wide string with wide '\0' character at end. |
| */ |
| public String readVariableWideString(Charset charset) { |
| |
| int start = cursor; |
| |
| // Find end of string |
| while (readUnsignedShortLE() != 0) { |
| } |
| |
| String string = new String(data, offset + start, cursor - start - 2, charset); |
| |
| return string; |
| } |
| |
| /** |
| * Get bytes as lightweight slice. Cursor is advanced by data length. |
| */ |
| public ByteBuffer readBytes(int dataLength) { |
| if (cursor + dataLength > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read " + dataLength + " bytes from this buffer: " + this + "."); |
| |
| ByteBuffer slice = slice(cursor, dataLength, false); |
| cursor += dataLength; |
| return slice; |
| } |
| |
| /** |
| * Cursor is advanced by given number of bytes. |
| */ |
| public void skipBytes(int numOfBytes) { |
| if (cursor + numOfBytes > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot read " + numOfBytes + " bytes from this buffer: " + this + "."); |
| |
| cursor += numOfBytes; |
| } |
| |
| /** |
| * Write byte. Cursor is advanced by 1. |
| */ |
| public void writeByte(int b) { |
| if (cursor + 1 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot write 1 byte to this buffer: " + this + "."); |
| |
| data[offset + cursor] = (byte)b; |
| cursor += 1; |
| } |
| |
| /** |
| * Write short in network order. Cursor is advanced by 2. |
| */ |
| public void writeShort(int x) { |
| if (cursor + 2 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot write 2 bytes to this buffer: " + this + "."); |
| |
| data[offset + cursor] = (byte)(x >> 8); |
| data[offset + cursor + 1] = (byte)x; |
| cursor += 2; |
| } |
| |
| /** |
| * Write short in little endian order. Cursor is advanced by 2. |
| */ |
| public void writeShortLE(int x) { |
| if (cursor + 2 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot write 2 bytes to this buffer: " + this + "."); |
| |
| data[offset + cursor + 1] = (byte)(x >> 8); |
| data[offset + cursor] = (byte)x; |
| cursor += 2; |
| } |
| |
| /** |
| * Write int in network order. Cursor is advanced by 4. |
| */ |
| public void writeInt(int i) { |
| if (cursor + 4 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot write 4 bytes to this buffer: " + this + "."); |
| |
| data[offset + cursor] = (byte)(i >> 24); |
| data[offset + cursor + 1] = (byte)(i >> 16); |
| data[offset + cursor + 2] = (byte)(i >> 8); |
| data[offset + cursor + 3] = (byte)i; |
| cursor += 4; |
| } |
| |
| public void writeIntLE(int i) { |
| if (cursor + 4 > length) |
| throw new ArrayIndexOutOfBoundsException("Cannot write 4 bytes to this buffer: " + this + "."); |
| |
| data[offset + cursor] = (byte)i; |
| data[offset + cursor + 1] = (byte)(i >> 8); |
| data[offset + cursor + 2] = (byte)(i >> 16); |
| data[offset + cursor + 3] = (byte)(i >> 24); |
| cursor += 4; |
| } |
| |
| /** |
| * Write int in variable length format. Cursor is advanced by number of bytes |
| * written (1-5). |
| * |
| * Topmost bit of each byte is set to 1 to indicate that next byte has data. |
| */ |
| public void writeVariableIntLE(int i) { |
| while (i != 0) { |
| // Get lower bits of number |
| int b = i & 0x7f; |
| i >>= 7; |
| |
| if (i > 0) |
| // Set topmost bit of byte to indicate that next byte(s) contains |
| // remainder bits |
| b |= 0x80; |
| |
| writeByte(b); |
| } |
| } |
| |
| /** |
| * Write short in variable length format. Cursor is advanced by number of |
| * bytes written (1-2). |
| * |
| * Topmost bit of first byte is set to 1 to indicate that next byte has data. |
| */ |
| public void writeVariableShort(int length) { |
| if (length > 0x7f | length < 0) |
| writeShort(length | 0x8000); |
| else |
| writeByte(length); |
| } |
| |
| /** |
| * Prepend given data to this byte buffer. |
| */ |
| public void prepend(ByteBuffer buf) { |
| prepend(buf.data, buf.offset, buf.length); |
| } |
| |
| /** |
| * Prepend given data to this byte buffer. |
| */ |
| public void prepend(byte[] data) { |
| prepend(data, 0, data.length); |
| } |
| |
| /** |
| * Prepend given data to this byte buffer. |
| */ |
| public void prepend(byte[] data, int offset, int length) { |
| if (!isSoleOwner()) { |
| throw new RuntimeException("Create full copy of this byte buffer data for modification. refCount: " + refCount + "."); |
| } |
| |
| // If there is no enough space for header to prepend |
| if (!(this.offset >= length)) { |
| throw new RuntimeException("Reserve data to have enough space for header."); |
| } |
| |
| // Copy header |
| System.arraycopy(data, offset, this.data, this.offset - length, length); |
| |
| // Extend byte range to include header |
| this.offset -= length; |
| this.length += length; |
| cursor += length; |
| } |
| |
| /** |
| * Write byte representation of given string, without string terminators (zero |
| * or zeroes at end of string). |
| */ |
| public void writeString(String str, Charset charset) { |
| writeBytes(str.getBytes(charset)); |
| } |
| |
| /** |
| * Write string of fixed size. When string is shorted, empty space is filled |
| * with zeros. When string is larger, it is truncated. |
| */ |
| public void writeFixedString(int length, String str, Charset charset) { |
| byte[] bytes = str.getBytes(charset); |
| writeBytes(bytes, 0, Math.min(bytes.length, length)); |
| |
| for (int i = bytes.length; i < length; i++) |
| writeByte(0); |
| } |
| |
| public void writeBytes(ByteBuffer buf) { |
| writeBytes(buf.data, buf.offset, buf.length); |
| } |
| |
| public void writeBytes(byte[] bytes) { |
| writeBytes(bytes, 0, bytes.length); |
| } |
| |
| public void writeBytes(byte[] bytes, int offset, int length) { |
| System.arraycopy(bytes, offset, data, this.offset + cursor, length); |
| cursor += length; |
| } |
| |
| /** |
| * Reduce length of buffer to cursor position. |
| */ |
| public void trimAtCursor() { |
| length = cursor; |
| } |
| |
| /** |
| * Rewind cursor to beginning of the buffer. |
| */ |
| public void rewindCursor() { |
| cursor = 0; |
| } |
| |
| /** |
| * Read RGB color in LE order. Cursor is advanced by 3. |
| * |
| * @return color as int, with red in lowest octet. |
| */ |
| public int readRGBColor() { |
| return readUnsignedByte() | (readUnsignedByte() << 8) | (readUnsignedByte() << 16); |
| } |
| |
| public void assertThatBufferIsFullyRead() { |
| if (cursor != length) |
| throw new RuntimeException("Data in buffer is not read fully. Buf: " + this + "."); |
| } |
| |
| @Override |
| public int hashCode() { |
| final int prime = 31; |
| int result = 1; |
| |
| int end = offset + length; |
| for (int i = offset; i < end; i++) |
| result = 31 * result + data[i]; |
| |
| result = prime * result + length; |
| return result; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (this == obj) |
| return true; |
| |
| if (obj == null) |
| return false; |
| |
| // Does not work in case of anonymous type(s) |
| if (getClass() != obj.getClass()) |
| return false; |
| |
| ByteBuffer other = (ByteBuffer)obj; |
| if (length != other.length) |
| return false; |
| |
| for (int i = 0; i < length; i++) |
| if (data[offset + i] != other.data[other.offset + i]) |
| return false; |
| |
| return true; |
| } |
| |
| /** |
| * Return length of data left after cursor. |
| */ |
| public int remainderLength() { |
| if (length >= cursor) |
| return length - cursor; |
| else |
| throw new RuntimeException("Inconsistent state of buffer: cursor is after end of buffer: " + this + "."); |
| } |
| |
| public Set<String> getMetadataKeys() { |
| if (metadata != null) |
| return metadata.keySet(); |
| else |
| return new HashSet<String>(0); |
| } |
| |
| /** |
| * Return unsigned value of byte at given position relative to cursor. Cursor |
| * is not advanced. |
| */ |
| public int peekUnsignedByte(int i) { |
| return data[offset + cursor + i] & 0xff; |
| } |
| |
| /** |
| * Trim few first bytes. |
| */ |
| public void trimHeader(int length) { |
| offset += length; |
| this.length -= length; |
| rewindCursor(); |
| } |
| |
| } |
