File	Doc	Category	Size	Date	Package
ByteArray.java	API Doc	Android 5.1 API	10815	Thu Mar 12 22:18:30 GMT 2015	com.android.dx.util

ByteArray

• java.lang.Object

Fields Summary
private final byte[]	bytes {@code non-null;} underlying array
private final int	start {@code >= 0}; start index of the slice (inclusive)
private final int	size {@code >= 0, <= bytes.length}; size computed as {@code end - start} (in the constructor)

Constructors Summary
public ByteArray(byte[] bytes, int start, int end) Constructs an instance. param bytes {@code non-null;} the underlying array param start {@code >= 0;} start index of the slice (inclusive) param end {@code >= start, <= bytes.length;} end index of the slice (exclusive) if (bytes == null) { throw new NullPointerException("bytes == null"); } if (start < 0) { throw new IllegalArgumentException("start < 0"); } if (end < start) { throw new IllegalArgumentException("end < start"); } if (end > bytes.length) { throw new IllegalArgumentException("end > bytes.length"); } this.bytes = bytes; this.start = start; this.size = end - start;
public ByteArray(byte[] bytes) Constructs an instance from an entire {@code byte[]}. param bytes {@code non-null;} the underlying array this(bytes, 0, bytes.length);

Methods Summary
private void	checkOffsets(int s, int e) Checks a range of offsets for validity, throwing if invalid. param s start offset (inclusive) param e end offset (exclusive) if ((s < 0) || (e < s) || (e > size)) { throw new IllegalArgumentException("bad range: " + s + ".." + e + "; actual size " + size); }
public int	getByte(int off) Gets the {@code signed byte} value at a particular offset. param off {@code >= 0, < size();} offset to fetch return {@code signed byte} at that offset checkOffsets(off, off + 1); return getByte0(off);
private int	getByte0(int off) Gets the {@code signed byte} value at the given offset, without doing any argument checking. param off offset to fetch return byte at that offset return bytes[start + off];
public void	getBytes(byte[] out, int offset) Copies the contents of this instance into the given raw {@code byte[]} at the given offset. The given array must be large enough. param out {@code non-null;} array to hold the output param offset {@code non-null;} index into {@code out} for the first byte of output if ((out.length - offset) < size) { throw new IndexOutOfBoundsException("(out.length - offset) < " + "size()"); } System.arraycopy(bytes, start, out, offset, size);
public int	getInt(int off) Gets the {@code signed int} value at a particular offset. param off {@code >= 0, < (size() - 3);} offset to fetch return {@code signed int} at that offset checkOffsets(off, off + 4); return (getByte0(off) << 24) | (getUnsignedByte0(off + 1) << 16) | (getUnsignedByte0(off + 2) << 8) | getUnsignedByte0(off + 3);
public long	getLong(int off) Gets the {@code signed long} value at a particular offset. param off {@code >= 0, < (size() - 7);} offset to fetch return {@code signed int} at that offset checkOffsets(off, off + 8); int part1 = (getByte0(off) << 24) | (getUnsignedByte0(off + 1) << 16) | (getUnsignedByte0(off + 2) << 8) | getUnsignedByte0(off + 3); int part2 = (getByte0(off + 4) << 24) | (getUnsignedByte0(off + 5) << 16) | (getUnsignedByte0(off + 6) << 8) | getUnsignedByte0(off + 7); return (part2 & 0xffffffffL) | ((long) part1) << 32;
public int	getShort(int off) Gets the {@code signed short} value at a particular offset. param off {@code >= 0, < (size() - 1);} offset to fetch return {@code signed short} at that offset checkOffsets(off, off + 2); return (getByte0(off) << 8) | getUnsignedByte0(off + 1);
public int	getUnsignedByte(int off) Gets the {@code unsigned byte} value at a particular offset. param off {@code >= 0, < size();} offset to fetch return {@code unsigned byte} at that offset checkOffsets(off, off + 1); return getUnsignedByte0(off);
private int	getUnsignedByte0(int off) Gets the {@code unsigned byte} value at the given offset, without doing any argument checking. param off offset to fetch return byte at that offset return bytes[start + off] & 0xff;
public int	getUnsignedShort(int off) Gets the {@code unsigned short} value at a particular offset. param off {@code >= 0, < (size() - 1);} offset to fetch return {@code unsigned short} at that offset checkOffsets(off, off + 2); return (getUnsignedByte0(off) << 8) | getUnsignedByte0(off + 1);
public com.android.dx.util.ByteArray$MyDataInputStream	makeDataInputStream() Gets a {@code DataInputStream} that reads from this instance, with the cursor starting at the beginning of this instance's data. Note: The returned instance may be cast to {@link #GetCursor} if needed. return {@code non-null;} an appropriately-constructed {@code DataInputStream} instance return new MyDataInputStream(makeInputStream());
public com.android.dx.util.ByteArray$MyInputStream	makeInputStream() Gets a {@code InputStream} that reads from this instance, with the cursor starting at the beginning of this instance's data. Note: The returned instance may be cast to {@link #GetCursor} if needed. return {@code non-null;} an appropriately-constructed {@code InputStream} instancex return new MyInputStream();
public int	size() Gets the size of the array, in bytes. return {@code >= 0;} the size return size;
public com.android.dx.util.ByteArray	slice(int start, int end) Returns a slice (that is, a sub-array) of this instance. param start {@code >= 0;} start index of the slice (inclusive) param end {@code >= start, <= size();} end index of the slice (exclusive) return {@code non-null;} the slice checkOffsets(start, end); return new ByteArray(bytes, start + this.start, end + this.start);
public int	underlyingOffset(int offset, byte[] bytes) Returns the offset into the given array represented by the given offset into this instance. param offset offset into this instance param bytes {@code non-null;} (alleged) underlying array return corresponding offset into {@code bytes} throws IllegalArgumentException thrown if {@code bytes} is not the underlying array of this instance if (bytes != this.bytes) { throw new IllegalArgumentException("wrong bytes"); } return start + offset;