FileDocCategorySizeDatePackage
ByteArray.javaAPI DocAndroid 5.1 API10815Thu Mar 12 22:18:30 GMT 2015com.android.dx.util

ByteArray

public final class ByteArray extends Object
Wrapper for a {@code byte[]}, which provides read-only access and can "reveal" a partial slice of the underlying array. Note: Multibyte accessors all use big-endian order.

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 voidcheckOffsets(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 intgetByte(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 intgetByte0(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 voidgetBytes(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 intgetInt(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 longgetLong(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 intgetShort(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 intgetUnsignedByte(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 intgetUnsignedByte0(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 intgetUnsignedShort(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$MyDataInputStreammakeDataInputStream()
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$MyInputStreammakeInputStream()
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 intsize()
Gets the size of the array, in bytes.

return
{@code >= 0;} the size

        return size;
    
public com.android.dx.util.ByteArrayslice(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 intunderlyingOffset(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;