DynamicByteArray

java.lang.Object
- com.partnersoft.data.DynamicArray
- - com.partnersoft.data.DynamicByteArray

```
public class DynamicByteArray
extends DynamicArray
```
A managed, dynamically sized array of bytes with many I/O functions.
Since this class is often used to read and write strange binary formats, a plethora of very specific read and write methods are provided in addition to the usual DynamicArray homework. We have done our best to ensure high performance.
Since all DynamicArrays track which items actually hold content, this can be a very useful way to manage binary data in memory; you can use a DynamicByteArray somewhat like a file, for example. Care should be exercised, however, lest this turn into the universal hammer for all I/O purposes. There are more appropriate tools for some uses in java.io and java.nio.
There are several distinct method name patterns in this class.
Methods like "readFoo" are designed to read some number of bytes in the specified "Foo" format and return the result. If the read method takes a position argument, it does not change the start and end markers. If it does not take an argument, then it uses the start marker AND moves the start marker to reflect that the bytes have been read and therefore "used up".
Similarly, methods like "writeFoo" are designed to convert the argument from the specified "Foo" format into bytes. If the write method takes a position argument, it overwrites existing data in the array. If not, it appends the bytes to the end of the array and increments the end variable appropriately.
The format descriptions are a bit cryptic. They generally combine endianness with byte size and type. For example, Int32 is a standard (for Java) 32-bit big-endian signed integer, taking up four bytes. Int32LE is a little-endian integer of the same size. UInt8 is an unsigned, single-byte integer (0-255). Etc. Hopefully these will remove some of the pain of reading strange file formats.
Read and write methods for the common, Java primitive types are included as well, and work the same as they do in DataInput and DataOutput. While they are in many ways redundant, they are nicely idiomatic for Java-centric data storage.
Copyright 2001-2007 Partner Software, Inc.

Author:

Paul Reavis

Field Summary

Fields
Modifier and Type Field and Description

byte[] array
- Fields inherited from class com.partnersoft.data.DynamicArray
  arrayObject, capacity, end, fastGrowthFactor, fastGrowthLimit, slowGrowthAmount, start

Fields
Modifier and Type	Field and Description
`byte[]`	`array`

Constructor Summary

Constructors
Constructor and Description
`DynamicByteArray()` Creates an empty byte array with zero capacity.
`DynamicByteArray(byte... array)` Creates a DynamicByteArray with the given internal array.
`DynamicByteArray(int capacity)` Creates an empty byte array of the given initial capacity.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`append(byte... bytes)` Appends a copy of the contents of the given array to this one.
`long`	`checksum()` Returns a CRC32 checksum of the contents.
`boolean`	`equals(java.lang.Object nother)`
`void`	`fillWith(int value)` Fills the array with the given value.
`void`	`fillWith(int value, int from, int to)` Fills the array with the given value.
`int`	`hashCode()`
`int`	`indexOf(byte... matchThis)` Searches the contents for a match on the given binary array.
`void`	`inputFromData(java.io.DataInput innie, int howMuch)` Fills this DynamicByteArray with data from the given `DataInput`, appending it to the end of any existing data.
`void`	`inputFromStream(java.io.InputStream innie, int howMuch)` Fills this DynamicByteArray with data from the given stream, appending it to the end of any existing data.
`void`	`newArray(int size)` Allocates a new, empty array of the given size and assign it to the arrayObject property.
`void`	`outputToData(java.io.DataOutput outie)` Writes the entire contents to a `DataOutput`.
`void`	`outputToData(java.io.DataOutput outie, int startPos, int endPos)` Writes partial contents to a `DataOutput`.
`void`	`outputToStream(java.io.OutputStream outie)` Writes the entire contents to a `OutputStream`.
`void`	`outputToStream(java.io.OutputStream outie, int startPos, int endPos)` Writes partial contents to a `OutputStream`.
`java.lang.String`	`readAscii(int byteSize)`
`java.lang.String`	`readAscii(int byteSize, int whereAt)`
`boolean`	`readBoolean()` Reads a single boolean from the start position.
`boolean`	`readBoolean(int whereAt)` Reads a single boolean from the given position.
`byte`	`readByte()` Read a single 8-bit byte from the current start position.
`byte`	`readByte(int whereAt)` Read a single 8-bit byte from the given position.
`char`	`readChar()` Reads a single two-byte char from the start position.
`char`	`readChar(int whereAt)` Reads a single two-byte char from the given position.
`double`	`readDouble()` Reads a 64-bit floating-point value from 8 bytes using big-endian order.
`double`	`readDouble(int whereAt)` Reads a 64-bit floating-point value from 8 bytes using big-endian order.
`float`	`readFloat()` Reads a 32-bit floating-point value from 4 bytes using big-endian order.
`float`	`readFloat(int whereAt)` Reads a 32-bit floating-point value from 4 bytes using big-endian order.
`float`	`readFloat32()` Reads a 32-bit floating-point value from 4 bytes using big-endian order.
`float`	`readFloat32(int whereAt)` Reads a 32-bit floating-point value from 4 bytes using big-endian order.
`float`	`readFloat32LE()` Reads a 32-bit floating-point value from 4 bytes using little-endian order.
`float`	`readFloat32LE(int whereAt)` Reads a 32-bit floating-point value from 4 bytes using little-endian order.
`double`	`readFloat64()` Reads a 64-bit floating-point value from 8 bytes using big-endian order.
`double`	`readFloat64(int whereAt)` Reads a 64-bit floating-point value from 8 bytes using big-endian order.
`double`	`readFloat64LE()` Reads a 64-bit floating-point value from 8 bytes using little-endian order.
`double`	`readFloat64LE(int whereAt)` Reads a 64-bit floating-point value from 8 bytes using little-endian order.
`int`	`readInt()` Reads a signed 32-bit integer value from 4 bytes in big-endian order.
`int`	`readInt(int whereAt)` Reads a signed 32-bit integer value from 4 bytes in big-endian order.
`short`	`readInt16()` Reads a signed 16-bit integer value from 2 bytes in big-endian order.
`short`	`readInt16(int whereAt)` Reads a signed 16-bit integer value from 2 bytes in big-endian order.
`short`	`readInt16LE()` Reads a signed 16-bit integer value from 2 bytes in little-endian order.
`short`	`readInt16LE(int whereAt)` Reads a signed 16-bit integer value from 2 bytes in little-endian order.
`int`	`readInt32()` Reads a signed 32-bit integer value from 4 bytes in big-endian order.
`int`	`readInt32(int whereAt)` Reads a signed 32-bit integer value from 4 bytes in big-endian order.
`int`	`readInt32LE()` Reads a signed 32-bit integer value from 4 bytes in little-endian order.
`int`	`readInt32LE(int whereAt)` Reads a signed 32-bit integer value from 4 bytes in little-endian order.
`long`	`readInt64()` Reads a signed 64-bit integer value from 8 bytes in big-endian order.
`long`	`readInt64(int whereAt)` Reads a signed 64-bit integer value from 8 bytes in big-endian order.
`long`	`readInt64LE()` Reads a signed 64-bit integer value from 8 bytes in little-endian order.
`long`	`readInt64LE(int whereAt)` Reads a signed 64-bit integer value from 8 bytes in little-endian order.
`byte`	`readInt8()` Read a single 8-bit byte from the current start position.
`byte`	`readInt8(int whereAt)` Read a single 8-bit byte from the given position.
`long`	`readLong()` Reads a signed 64-bit integer value from 8 bytes in big-endian order.
`long`	`readLong(int whereAt)` Reads a signed 64-bit integer value from 8 bytes in big-endian order.
`short`	`readShort()` Reads a signed 16-bit integer value from 2 bytes in big-endian order.
`short`	`readShort(int whereAt)` Reads a signed 16-bit integer value from 2 bytes in big-endian order.
`int`	`readUInt16()` Reads a unsigned 16-bit integer value from 2 bytes in big-endian order.
`int`	`readUInt16(int whereAt)` Reads a unsigned 16-bit integer value from 2 bytes in big-endian order.
`int`	`readUInt16LE()` Reads a unsigned 16-bit integer value from 2 bytes in little-endian order.
`int`	`readUInt16LE(int whereAt)` Reads a unsigned 16-bit integer value from 2 bytes in little-endian order.
`long`	`readUInt32()` Reads a unsigned 32-bit integer value from 4 bytes in big-endian order.
`long`	`readUInt32(int whereAt)` Reads a unsigned 32-bit integer value from 4 bytes in big-endian order.
`long`	`readUInt32LE()` Reads a unsigned 32-bit integer value from 4 bytes in little-endian order.
`long`	`readUInt32LE(int whereAt)` Reads a unsigned 32-bit integer value from 4 bytes in little-endian order.
`int`	`readUInt8()` Read a single unsigned 8-bit byte from the current start position.
`int`	`readUInt8(int whereAt)` Read a single 8-bit byte from the given position.
`java.lang.String`	`readUTF()` Reads a string in modified UTF format as used by `DataInput` and `DataOutput`.
`long`	`readVariableLengthQuantity()` Reads a variable-length unsigned integer using the high bit for each sequential byte as the extension bit.
`java.lang.String`	`toBinaryString()` Returns a String representation, in binary notation, of the entire contents.
`java.lang.String`	`toBinaryString(int startPos, int endPos)` Returns a String representation, in binary notation, of the contents.
`java.lang.String`	`toBinaryString(int startPos, int endPos, int groupSize, int lineSize)` Returns a String representation, in binary notation, of the contents.
`byte[]`	`toByteArray()` Returns a fresh, independent copy of the contents as a byte array.
`java.lang.String`	`toHexString()` Returns a String representation, in hexadecimal notation, of the entire contents.
`java.lang.String`	`toHexString(int startPos, int endPos)` Returns a String representation, in hexadecimal notation, of the contents.
`java.lang.String`	`toHexString(int startPos, int endPos, int groupSize, int lineSize)` Returns a String representation, in hexadecimal notation, of the contents.
`void`	`writeAscii(java.lang.String value, int byteSize)` Appends a fixed-width String in US-ASCII format, with no terminating null character.
`void`	`writeAscii(java.lang.String value, int byteSize, int whereAt)` Writes a fixed-width String in US-ASCII format at the given position, with no terminating null character.
`void`	`writeBoolean(boolean what)` Writes a single boolean to the current end position.
`void`	`writeBoolean(boolean what, int whereAt)` Writes a single boolean to the given position.
`void`	`writeByte(byte what)` Writes a single 8-bit byte to the current end position.
`void`	`writeByte(byte what, int whereAt)` Writes a single 8-bit byte to the given position.
`void`	`writeBytes(byte[] bytes, int whereAt)` Writes the given bytes to the given position.
`void`	`writeChar(char what)` Writes a single char to the current end position.
`void`	`writeChar(char what, int whereAt)` Writes a single two-byte char to the given position.
`void`	`writeDouble(double what)` Writes a 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeDouble(double what, int whereAt)` Writes a 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeFloat(float what)` Writes a 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeFloat(float what, int whereAt)` Writes a 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeFloat32(float what)` Writes a 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeFloat32(float what, int whereAt)` Writes a 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeFloat32LE(float what)` Writes a 32-bit integer value into 4 bytes using little-endian order.
`void`	`writeFloat32LE(float what, int whereAt)` Writes a 32-bit integer value into 4 bytes using little-endian order.
`void`	`writeFloat64(double what)` Writes a 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeFloat64(double what, int whereAt)` Writes a 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeFloat64LE(double what)` Writes a 64-bit integer value into 8 bytes using little-endian order.
`void`	`writeFloat64LE(double what, int whereAt)` Writes a 64-bit integer value into 8 bytes using little-endian order.
`void`	`writeHexStringAsBytes(java.lang.String hex)` Parses the hexadecimal notation and writes the resulting bytes to the position given.
`void`	`writeHexStringAsBytes(java.lang.String hex, int whereAt)` Parses the hexadecimal notation and appends the resulting bytes on the end of the array.
`void`	`writeInt(int what)` Writes a signed 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeInt(int what, int whereAt)` Writes a signed 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeInt16(short what)` Writes a signed 16-bit integer value into 2 bytes using big-endian order.
`void`	`writeInt16(short what, int whereAt)` Writes a signed 16-bit integer value into 2 bytes using big-endian order.
`void`	`writeInt16LE(short what)` Writes a signed 16-bit integer value into 2 bytes using little-endian order.
`void`	`writeInt16LE(short what, int whereAt)` Writes a signed 16-bit integer value into 2 bytes using little-endian order.
`void`	`writeInt32(int what)` Writes a signed 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeInt32(int what, int whereAt)` Writes a signed 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeInt32LE(int what)` Writes a signed 32-bit integer value into 4 bytes using little-endian order.
`void`	`writeInt32LE(int what, int whereAt)` Writes a signed 32-bit integer value into 4 bytes using little-endian order.
`void`	`writeInt64(long what)` Writes a signed 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeInt64(long what, int whereAt)` Writes a signed 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeInt64LE(long what)` Writes a signed 64-bit integer value into 8 bytes using little-endian order.
`void`	`writeInt64LE(long what, int whereAt)` Writes a signed 64-bit integer value into 8 bytes using little-endian order.
`void`	`writeInt8(byte what)` Writes a single 8-bit byte to the current end position.
`void`	`writeInt8(byte what, int whereAt)` Writes a single 8-bit byte to the given position.
`void`	`writeLong(long what)` Writes a signed 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeLong(long what, int whereAt)` Writes a signed 64-bit integer value into 8 bytes using big-endian order.
`void`	`writeShort(short what)` Writes a signed 16-bit integer value into 2 bytes using big-endian order.
`void`	`writeShort(short what, int whereAt)` Writes a signed 16-bit integer value into 2 bytes using big-endian order.
`void`	`writeUInt16(int what)` Writes a unsigned 16-bit integer value into 2 bytes using big-endian order.
`void`	`writeUInt16(int what, int whereAt)` Writes a unsigned 16-bit integer value into 2 bytes using big-endian order.
`void`	`writeUInt16LE(int what)` Writes a unsigned 16-bit integer value into 2 bytes using little-endian order.
`void`	`writeUInt16LE(int what, int whereAt)` Writes a unsigned 16-bit integer value into 2 bytes using little-endian order.
`void`	`writeUInt32(long what)` Writes a unsigned 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeUInt32(long what, int whereAt)` Writes a unsigned 32-bit integer value into 4 bytes using big-endian order.
`void`	`writeUInt32LE(long what)` Writes a unsigned 32-bit integer value into 4 bytes using little-endian order.
`void`	`writeUInt32LE(long what, int whereAt)` Writes a unsigned 32-bit integer value into 4 bytes using little-endian order.
`void`	`writeUInt8(int what)` Writes a single unsigned 8-bit byte to the current end position.
`void`	`writeUInt8(int what, int whereAt)` Writes a single 8-bit byte to the given position.
`void`	`writeUTF(java.lang.String value)` Writes a string in modified UTF format as used by `DataInput` and `DataOutput`.
`int`	`writeVariableLengthQuantity(long value)` Writes a variable-length unsigned integer using the high bit for each sequential byte as the extension bit.
`void`	`zero()` Zeros the entire array.

Methods inherited from class com.partnersoft.data.DynamicArray
append, clear, copy, copy, copyExactly, copyFrom, copyTo, insert, isEmpty, makeRoomFor, makeRoomFor, pack, remove, size, subsection, tidy, toString

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - array
```
public byte[] array
```
- Constructor Detail
  - DynamicByteArray
```
public DynamicByteArray()
```
    Creates an empty byte array with zero capacity.
  - DynamicByteArray
```
public DynamicByteArray(int capacity)
```
    Creates an empty byte array of the given initial capacity.
    
    Parameters:
    capacity - initial capacity
  - DynamicByteArray
```
public DynamicByteArray(byte... array)
```
    Creates a DynamicByteArray with the given internal array. While it will initially place this in the array variable, note that this internal array will be discarded if the DynamicByteArray is resized! However, this can be a very useful constructor if you are using the DynamicByteArray for reading in weird binary data that you have loaded in some other fashion, and don't want the additional expense of copying the array.
    Start is set to 0 and end is set to array.length. Change them after constructing if you don't like those values.
    Note that this also works as varargs... if for some reason you like typing in hex bytes in your constructor.
    
    Parameters:
    array - source array for this DynamicByteArray; it is used, not copied
- Method Detail
  - newArray
```
public final void newArray(int size)
```
    Description copied from class: DynamicArray
    Allocates a new, empty array of the given size and assign it to the arrayObject property. It is assumed that subclasses will also set it to a variable of the correct class (e.g. char[]) for ease of access as well. Copying of existing contents is Dynamic by this superclass. Your code should look something like this:
```
 public abstract void newArray(int size) {
     arrayObject = array = new Foo[size];
 }
 
```
    Specified by:
    
    newArray in class DynamicArray
  - append
```
public final void append(byte... bytes)
```
    Appends a copy of the contents of the given array to this one. Increments the DynamicArray.end variable by notherArray.length.
    
    Parameters:
    bytes - array to append from
  - toByteArray
```
public final byte[] toByteArray()
```
    Returns a fresh, independent copy of the contents as a byte array.
    
    Returns:
    new byte array with same contents
  - checksum
```
public final long checksum()
```
    Returns a CRC32 checksum of the contents.
    
    Returns:
    CRC32 checksum of contents
  - indexOf
```
public int indexOf(byte... matchThis)
```
    Searches the contents for a match on the given binary array. Sort of like a substring search. But with bytes.
    
    Parameters:
    matchThis - byte sequence to search for
    
    Returns:
    index of first found matching sequence; -1 if none found
  - zero
```
public void zero()
```
    Zeros the entire array.
  - fillWith
```
public void fillWith(int value)
```
    Fills the array with the given value.
  - fillWith
```
public void fillWith(int value,
            int from,
            int to)
```
    Fills the array with the given value.
  - writeBytes
```
public void writeBytes(byte[] bytes,
              int whereAt)
```
    Writes the given bytes to the given position.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public final boolean equals(java.lang.Object nother)
```
    Overrides:
    
    equals in class java.lang.Object
  - writeHexStringAsBytes
```
public final void writeHexStringAsBytes(java.lang.String hex)
```
    Parses the hexadecimal notation and writes the resulting bytes to the position given.
    
    Parameters:
    hex - input hexadecimal
  - writeHexStringAsBytes
```
public final void writeHexStringAsBytes(java.lang.String hex,
                         int whereAt)
```
    Parses the hexadecimal notation and appends the resulting bytes on the end of the array.
    
    Parameters:
    hex - input hexadecimal
  - toHexString
```
public final java.lang.String toHexString()
```
    Returns a String representation, in hexadecimal notation, of the entire contents. Same as toHexString(int, int, int, int) with default values of startPos=start, endPos=end, groupSize=2 and lineSize=16.
    
    Returns:
    String of numbers and letters for you to puzzle over
  - toHexString
```
public final java.lang.String toHexString(int startPos,
                           int endPos)
```
    Returns a String representation, in hexadecimal notation, of the contents. Same as toHexString(int, int, int, int) with default values of groupSize=2 and lineSize=16.
    
    Parameters:
    startPos - where to start, inclusive
    endPos - where to end, exclusive
    
    Returns:
    String of numbers and letters for you to puzzle over
  - toHexString
```
public final java.lang.String toHexString(int startPos,
                           int endPos,
                           int groupSize,
                           int lineSize)
```
    Returns a String representation, in hexadecimal notation, of the contents.
    
    Parameters:
    startPos - where to start, inclusive
    endPos - where to end, exclusive
    groupSize - how many bytes in a group
    lineSize - how many bytes in a line
    
    Returns:
    String of numbers and letters for you to puzzle over
  - toBinaryString
```
public final java.lang.String toBinaryString()
```
    Returns a String representation, in binary notation, of the entire contents. Same as toBinaryString(int, int, int, int) with default values of startPos=start, endPos=end, groupSize=2 and lineSize=16.
    
    Returns:
    String of ones and zeros for you to puzzle over
  - toBinaryString
```
public final java.lang.String toBinaryString(int startPos,
                              int endPos)
```
    Returns a String representation, in binary notation, of the contents. Same as toBinaryString(int, int, int, int) with default values of groupSize=2 and lineSize=16.
    
    Parameters:
    startPos - where to start, inclusive
    endPos - where to end, exclusive
    
    Returns:
    String of ones and zeros for you to puzzle over
  - toBinaryString
```
public final java.lang.String toBinaryString(int startPos,
                              int endPos,
                              int groupSize,
                              int lineSize)
```
    Returns a String representation, in binary notation, of the contents.
    
    Parameters:
    startPos - where to start, inclusive
    endPos - where to end, exclusive
    groupSize - how many bytes in a group
    lineSize - how many bytes in a line
    
    Returns:
    String of ones and zeros for you to puzzle over
  - inputFromStream
```
public void inputFromStream(java.io.InputStream innie,
                   int howMuch)
                     throws java.io.IOException
```
    Fills this DynamicByteArray with data from the given stream, appending it to the end of any existing data.
    
    Parameters:
    innie - input to read input from
    howMuch - how many bytes to read
    
    Throws:
    
    java.io.IOException - if anything bad happens
  - inputFromData
```
public void inputFromData(java.io.DataInput innie,
                 int howMuch)
                   throws java.io.IOException
```
    Fills this DynamicByteArray with data from the given DataInput, appending it to the end of any existing data.
    
    Parameters:
    innie - input to read input from
    howMuch - how many bytes to read
    
    Throws:
    
    java.io.IOException - if anything bad happens
  - outputToStream
```
public void outputToStream(java.io.OutputStream outie)
                    throws java.io.IOException
```
    Writes the entire contents to a OutputStream.
    
    Parameters:
    outie - output to output to
    
    Throws:
    
    java.io.IOException - if something bad happens
  - outputToStream
```
public void outputToStream(java.io.OutputStream outie,
                  int startPos,
                  int endPos)
                    throws java.io.IOException
```
    Writes partial contents to a OutputStream.
    
    Parameters:
    outie - output to output to
    startPos - starting position (inclusive)
    endPos - ending position (exclusive)
    
    Throws:
    
    java.io.IOException - if something bad happens
  - outputToData
```
public void outputToData(java.io.DataOutput outie)
                  throws java.io.IOException
```
    Writes the entire contents to a DataOutput.
    
    Parameters:
    outie - output to output to
    
    Throws:
    
    java.io.IOException - if something bad happens
  - outputToData
```
public void outputToData(java.io.DataOutput outie,
                int startPos,
                int endPos)
                  throws java.io.IOException
```
    Writes partial contents to a DataOutput.
    
    Parameters:
    outie - output to output to
    startPos - starting position (inclusive)
    endPos - ending position (exclusive)
    
    Throws:
    
    java.io.IOException - if something bad happens
  - readUTF
```
public java.lang.String readUTF()
```
    Reads a string in modified UTF format as used by DataInput and DataOutput.
    
    Returns:
    String read
  - writeUTF
```
public void writeUTF(java.lang.String value)
```
    Writes a string in modified UTF format as used by DataInput and DataOutput.
    
    Parameters:
    value - String to be written
  - writeAscii
```
public void writeAscii(java.lang.String value,
              int byteSize)
```
    Appends a fixed-width String in US-ASCII format, with no terminating null character. Truncates or pads with blanks to fit in the given number of bytes.
  - writeAscii
```
public void writeAscii(java.lang.String value,
              int byteSize,
              int whereAt)
```
    Writes a fixed-width String in US-ASCII format at the given position, with no terminating null character. Truncates or pads with blanks to fit in the given number of bytes.
  - readAscii
```
public java.lang.String readAscii(int byteSize)
```
  - readAscii
```
public java.lang.String readAscii(int byteSize,
                         int whereAt)
```
  - readVariableLengthQuantity
```
public long readVariableLengthQuantity()
```
    Reads a variable-length unsigned integer using the high bit for each sequential byte as the extension bit.
    See http://en.wikipedia.org/wiki/Variable_length_unsigned_integer for the format description.
  - writeVariableLengthQuantity
```
public int writeVariableLengthQuantity(long value)
```
    Writes a variable-length unsigned integer using the high bit for each sequential byte as the extension bit.
    Returns the number of bytes used.
    See http://en.wikipedia.org/wiki/Variable_length_unsigned_integer for the format description.
  - readByte
```
public byte readByte()
```
    Read a single 8-bit byte from the current start position. Increments the start position as a side effect.
    
    Returns:
    8-bit integer value read
  - writeByte
```
public void writeByte(byte what)
```
    Writes a single 8-bit byte to the current end position. Increments the end position as a side effect.
    
    Parameters:
    what - 8-bit integer value to write
  - readByte
```
public byte readByte(int whereAt)
```
    Read a single 8-bit byte from the given position.
    
    Parameters:
    whereAt - position to read byte from
    
    Returns:
    8-bit integer value read
  - writeByte
```
public void writeByte(byte what,
             int whereAt)
```
    Writes a single 8-bit byte to the given position.
    
    Parameters:
    whereAt - position to write byte to
    what - 8-bit integer value to write
  - readInt8
```
public byte readInt8()
```
    Read a single 8-bit byte from the current start position. Increments the start position as a side effect.
    
    Returns:
    8-bit integer value read
  - writeInt8
```
public void writeInt8(byte what)
```
    Writes a single 8-bit byte to the current end position. Increments the end position as a side effect.
    
    Parameters:
    what - 8-bit integer value to write
  - readInt8
```
public byte readInt8(int whereAt)
```
    Read a single 8-bit byte from the given position.
    
    Parameters:
    whereAt - position to read byte from
    
    Returns:
    8-bit integer value read
  - writeInt8
```
public void writeInt8(byte what,
             int whereAt)
```
    Writes a single 8-bit byte to the given position.
    
    Parameters:
    whereAt - position to write byte to
    what - 8-bit integer value to write
  - readUInt8
```
public int readUInt8()
```
    Read a single unsigned 8-bit byte from the current start position. Increments the start position as a side effect.
    
    Returns:
    unsigned 8-bit integer value read
  - writeUInt8
```
public void writeUInt8(int what)
```
    Writes a single unsigned 8-bit byte to the current end position. Increments the end position as a side effect.
    
    Parameters:
    what - 8-bit integer value to write
  - readUInt8
```
public int readUInt8(int whereAt)
```
    Read a single 8-bit byte from the given position.
    
    Parameters:
    whereAt - position to read byte from
    
    Returns:
    8-bit integer value read
  - writeUInt8
```
public void writeUInt8(int what,
              int whereAt)
```
    Writes a single 8-bit byte to the given position.
    
    Parameters:
    whereAt - position to write byte to
    what - 8-bit integer value to write
  - readBoolean
```
public final boolean readBoolean(int whereAt)
```
    Reads a single boolean from the given position. Booleans are encoded as a single byte, 0 for false, anything else is true.
    
    Parameters:
    whereAt - position to read boolean from
    
    Returns:
    boolean value read
  - readBoolean
```
public final boolean readBoolean()
```
    Reads a single boolean from the start position. Increments the start position as a side effect. Booleans are encoded as a single byte, 0 for false, anything else is true.
    
    Returns:
    boolean value read
  - writeBoolean
```
public final void writeBoolean(boolean what,
                int whereAt)
```
    Writes a single boolean to the given position. Booleans are encoded as a single byte, 0 for false, anything else is true.
    
    Parameters:
    what - boolean value to write
    whereAt - position to write boolean to
  - writeBoolean
```
public final void writeBoolean(boolean what)
```
    Writes a single boolean to the current end position. Increments the end position as a side effect. Booleans are encoded as a single byte, 0 for false, anything else is true.
    
    Parameters:
    what - boolean value to write
  - readChar
```
public final char readChar(int whereAt)
```
    Reads a single two-byte char from the given position.
    
    Parameters:
    whereAt - position to read char from
    
    Returns:
    char value read
  - readChar
```
public final char readChar()
```
    Reads a single two-byte char from the start position. Increments the start position as a side effect.
    
    Returns:
    char value read
  - writeChar
```
public final void writeChar(char what,
             int whereAt)
```
    Writes a single two-byte char to the given position.
    
    Parameters:
    what - char value to write
    whereAt - position to write char to
  - writeChar
```
public final void writeChar(char what)
```
    Writes a single char to the current end position. Increments the end position as a side effect.
    
    Parameters:
    what - char value to write
  - readShort
```
public short readShort()
```
    Reads a signed 16-bit integer value from 2 bytes in big-endian order.
    
    Returns:
    16-bit integer value read
  - writeShort
```
public void writeShort(short what)
```
    Writes a signed 16-bit integer value into 2 bytes using big-endian order.
    
    Parameters:
    what - 16-bit integer value to write
  - readShort
```
public short readShort(int whereAt)
```
    Reads a signed 16-bit integer value from 2 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    16-bit integer value read
  - writeShort
```
public void writeShort(short what,
              int whereAt)
```
    Writes a signed 16-bit integer value into 2 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 16-bit integer value to write
  - readInt
```
public int readInt()
```
    Reads a signed 32-bit integer value from 4 bytes in big-endian order.
    
    Returns:
    32-bit integer value read
  - writeInt
```
public void writeInt(int what)
```
    Writes a signed 32-bit integer value into 4 bytes using big-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readInt
```
public int readInt(int whereAt)
```
    Reads a signed 32-bit integer value from 4 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit integer value read
  - writeInt
```
public void writeInt(int what,
            int whereAt)
```
    Writes a signed 32-bit integer value into 4 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 32-bit integer value to write
  - readLong
```
public long readLong()
```
    Reads a signed 64-bit integer value from 8 bytes in big-endian order.
    
    Returns:
    64-bit integer value read
  - writeLong
```
public void writeLong(long what)
```
    Writes a signed 64-bit integer value into 8 bytes using big-endian order.
    
    Parameters:
    what - 64-bit integer value to write
  - readLong
```
public long readLong(int whereAt)
```
    Reads a signed 64-bit integer value from 8 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    64-bit integer value read
  - writeLong
```
public void writeLong(long what,
             int whereAt)
```
    Writes a signed 64-bit integer value into 8 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 64-bit integer value to write
  - readFloat
```
public float readFloat()
```
    Reads a 32-bit floating-point value from 4 bytes using big-endian order.
    
    Returns:
    32-bit floating point value read
  - writeFloat
```
public void writeFloat(float what)
```
    Writes a 32-bit integer value into 4 bytes using big-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readFloat
```
public float readFloat(int whereAt)
```
    Reads a 32-bit floating-point value from 4 bytes using big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit floating point value read
  - writeFloat
```
public void writeFloat(float what,
              int whereAt)
```
    Writes a 32-bit integer value into 4 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start reading
    what - 32-bit integer value to write
  - readDouble
```
public double readDouble()
```
    Reads a 64-bit floating-point value from 8 bytes using big-endian order.
    
    Returns:
    64-bit floating point value read
  - writeDouble
```
public void writeDouble(double what)
```
    Writes a 64-bit integer value into 8 bytes using big-endian order.
    
    Parameters:
    what - 64-bit integer value to write
  - readDouble
```
public double readDouble(int whereAt)
```
    Reads a 64-bit floating-point value from 8 bytes using big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    64-bit floating point value read
  - writeDouble
```
public void writeDouble(double what,
               int whereAt)
```
    Writes a 64-bit integer value into 8 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start reading
    what - 64-bit integer value to write
  - readInt16
```
public short readInt16()
```
    Reads a signed 16-bit integer value from 2 bytes in big-endian order.
    
    Returns:
    16-bit integer value read
  - writeInt16
```
public void writeInt16(short what)
```
    Writes a signed 16-bit integer value into 2 bytes using big-endian order.
    
    Parameters:
    what - 16-bit integer value to write
  - readInt16
```
public short readInt16(int whereAt)
```
    Reads a signed 16-bit integer value from 2 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    16-bit integer value read
  - writeInt16
```
public void writeInt16(short what,
              int whereAt)
```
    Writes a signed 16-bit integer value into 2 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 16-bit integer value to write
  - readUInt16
```
public int readUInt16()
```
    Reads a unsigned 16-bit integer value from 2 bytes in big-endian order.
    
    Returns:
    16-bit integer value read
  - writeUInt16
```
public void writeUInt16(int what)
```
    Writes a unsigned 16-bit integer value into 2 bytes using big-endian order.
    
    Parameters:
    what - 16-bit integer value to write
  - readUInt16
```
public int readUInt16(int whereAt)
```
    Reads a unsigned 16-bit integer value from 2 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    16-bit integer value read
  - writeUInt16
```
public void writeUInt16(int what,
               int whereAt)
```
    Writes a unsigned 16-bit integer value into 2 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 16-bit integer value to write
  - readInt16LE
```
public short readInt16LE()
```
    Reads a signed 16-bit integer value from 2 bytes in little-endian order.
    
    Returns:
    16-bit integer value read
  - writeInt16LE
```
public void writeInt16LE(short what)
```
    Writes a signed 16-bit integer value into 2 bytes using little-endian order.
    
    Parameters:
    what - 16-bit integer value to write
  - readInt16LE
```
public short readInt16LE(int whereAt)
```
    Reads a signed 16-bit integer value from 2 bytes in little-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    16-bit integer value read
  - writeInt16LE
```
public void writeInt16LE(short what,
                int whereAt)
```
    Writes a signed 16-bit integer value into 2 bytes using little-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 16-bit integer value to write
  - readUInt16LE
```
public int readUInt16LE()
```
    Reads a unsigned 16-bit integer value from 2 bytes in little-endian order.
    
    Returns:
    16-bit integer value read
  - writeUInt16LE
```
public void writeUInt16LE(int what)
```
    Writes a unsigned 16-bit integer value into 2 bytes using little-endian order.
    
    Parameters:
    what - 16-bit integer value to write
  - readUInt16LE
```
public int readUInt16LE(int whereAt)
```
    Reads a unsigned 16-bit integer value from 2 bytes in little-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    16-bit integer value read
  - writeUInt16LE
```
public void writeUInt16LE(int what,
                 int whereAt)
```
    Writes a unsigned 16-bit integer value into 2 bytes using little-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 16-bit integer value to write
  - readInt32
```
public int readInt32()
```
    Reads a signed 32-bit integer value from 4 bytes in big-endian order.
    
    Returns:
    32-bit integer value read
  - writeInt32
```
public void writeInt32(int what)
```
    Writes a signed 32-bit integer value into 4 bytes using big-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readInt32
```
public int readInt32(int whereAt)
```
    Reads a signed 32-bit integer value from 4 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit integer value read
  - writeInt32
```
public void writeInt32(int what,
              int whereAt)
```
    Writes a signed 32-bit integer value into 4 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 32-bit integer value to write
  - readUInt32
```
public long readUInt32()
```
    Reads a unsigned 32-bit integer value from 4 bytes in big-endian order.
    
    Returns:
    32-bit integer value read
  - writeUInt32
```
public void writeUInt32(long what)
```
    Writes a unsigned 32-bit integer value into 4 bytes using big-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readUInt32
```
public long readUInt32(int whereAt)
```
    Reads a unsigned 32-bit integer value from 4 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit integer value read
  - writeUInt32
```
public void writeUInt32(long what,
               int whereAt)
```
    Writes a unsigned 32-bit integer value into 4 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 32-bit integer value to write
  - readInt32LE
```
public int readInt32LE()
```
    Reads a signed 32-bit integer value from 4 bytes in little-endian order.
    
    Returns:
    32-bit integer value read
  - writeInt32LE
```
public void writeInt32LE(int what)
```
    Writes a signed 32-bit integer value into 4 bytes using little-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readInt32LE
```
public int readInt32LE(int whereAt)
```
    Reads a signed 32-bit integer value from 4 bytes in little-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit integer value read
  - writeInt32LE
```
public void writeInt32LE(int what,
                int whereAt)
```
    Writes a signed 32-bit integer value into 4 bytes using little-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 32-bit integer value to write
  - readUInt32LE
```
public long readUInt32LE()
```
    Reads a unsigned 32-bit integer value from 4 bytes in little-endian order.
    
    Returns:
    32-bit integer value read
  - writeUInt32LE
```
public void writeUInt32LE(long what)
```
    Writes a unsigned 32-bit integer value into 4 bytes using little-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readUInt32LE
```
public long readUInt32LE(int whereAt)
```
    Reads a unsigned 32-bit integer value from 4 bytes in little-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit integer value read
  - writeUInt32LE
```
public void writeUInt32LE(long what,
                 int whereAt)
```
    Writes a unsigned 32-bit integer value into 4 bytes using little-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 32-bit integer value to write
  - readInt64
```
public long readInt64()
```
    Reads a signed 64-bit integer value from 8 bytes in big-endian order.
    
    Returns:
    64-bit integer value read
  - writeInt64
```
public void writeInt64(long what)
```
    Writes a signed 64-bit integer value into 8 bytes using big-endian order.
    
    Parameters:
    what - 64-bit integer value to write
  - readInt64
```
public long readInt64(int whereAt)
```
    Reads a signed 64-bit integer value from 8 bytes in big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    64-bit integer value read
  - writeInt64
```
public void writeInt64(long what,
              int whereAt)
```
    Writes a signed 64-bit integer value into 8 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 64-bit integer value to write
  - readInt64LE
```
public long readInt64LE()
```
    Reads a signed 64-bit integer value from 8 bytes in little-endian order.
    
    Returns:
    64-bit integer value read
  - writeInt64LE
```
public void writeInt64LE(long what)
```
    Writes a signed 64-bit integer value into 8 bytes using little-endian order.
    
    Parameters:
    what - 64-bit integer value to write
  - readInt64LE
```
public long readInt64LE(int whereAt)
```
    Reads a signed 64-bit integer value from 8 bytes in little-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    64-bit integer value read
  - writeInt64LE
```
public void writeInt64LE(long what,
                int whereAt)
```
    Writes a signed 64-bit integer value into 8 bytes using little-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start writing
    what - 64-bit integer value to write
  - readFloat32
```
public float readFloat32()
```
    Reads a 32-bit floating-point value from 4 bytes using big-endian order.
    
    Returns:
    32-bit floating point value read
  - writeFloat32
```
public void writeFloat32(float what)
```
    Writes a 32-bit integer value into 4 bytes using big-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readFloat32
```
public float readFloat32(int whereAt)
```
    Reads a 32-bit floating-point value from 4 bytes using big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit floating point value read
  - writeFloat32
```
public void writeFloat32(float what,
                int whereAt)
```
    Writes a 32-bit integer value into 4 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start reading
    what - 32-bit integer value to write
  - readFloat32LE
```
public float readFloat32LE()
```
    Reads a 32-bit floating-point value from 4 bytes using little-endian order.
    
    Returns:
    32-bit floating point value read
  - writeFloat32LE
```
public void writeFloat32LE(float what)
```
    Writes a 32-bit integer value into 4 bytes using little-endian order.
    
    Parameters:
    what - 32-bit integer value to write
  - readFloat32LE
```
public float readFloat32LE(int whereAt)
```
    Reads a 32-bit floating-point value from 4 bytes using little-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    32-bit floating point value read
  - writeFloat32LE
```
public void writeFloat32LE(float what,
                  int whereAt)
```
    Writes a 32-bit integer value into 4 bytes using little-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start reading
    what - 32-bit integer value to write
  - readFloat64
```
public double readFloat64()
```
    Reads a 64-bit floating-point value from 8 bytes using big-endian order.
    
    Returns:
    64-bit floating point value read
  - writeFloat64
```
public void writeFloat64(double what)
```
    Writes a 64-bit integer value into 8 bytes using big-endian order.
    
    Parameters:
    what - 64-bit integer value to write
  - readFloat64
```
public double readFloat64(int whereAt)
```
    Reads a 64-bit floating-point value from 8 bytes using big-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    64-bit floating point value read
  - writeFloat64
```
public void writeFloat64(double what,
                int whereAt)
```
    Writes a 64-bit integer value into 8 bytes using big-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start reading
    what - 64-bit integer value to write
  - readFloat64LE
```
public double readFloat64LE()
```
    Reads a 64-bit floating-point value from 8 bytes using little-endian order.
    
    Returns:
    64-bit floating point value read
  - writeFloat64LE
```
public void writeFloat64LE(double what)
```
    Writes a 64-bit integer value into 8 bytes using little-endian order.
    
    Parameters:
    what - 64-bit integer value to write
  - readFloat64LE
```
public double readFloat64LE(int whereAt)
```
    Reads a 64-bit floating-point value from 8 bytes using little-endian order. Starts reading at the specified position.
    
    Parameters:
    whereAt - position to start reading
    
    Returns:
    64-bit floating point value read
  - writeFloat64LE
```
public void writeFloat64LE(double what,
                  int whereAt)
```
    Writes a 64-bit integer value into 8 bytes using little-endian order. Starts writing at the specified position.
    
    Parameters:
    whereAt - position to start reading
    what - 64-bit integer value to write

Class DynamicByteArray

Field Summary

Fields inherited from class com.partnersoft.data.DynamicArray

Constructor Summary

Method Summary

Methods inherited from class com.partnersoft.data.DynamicArray

Methods inherited from class java.lang.Object

Field Detail

array

Constructor Detail

DynamicByteArray

DynamicByteArray

DynamicByteArray

Method Detail

newArray

append

toByteArray

checksum

indexOf

zero

fillWith

fillWith

writeBytes

hashCode

equals

writeHexStringAsBytes

writeHexStringAsBytes

toHexString

toHexString

toHexString

toBinaryString

toBinaryString

toBinaryString

inputFromStream

inputFromData

outputToStream

outputToStream

outputToData

outputToData

readUTF

writeUTF

writeAscii

writeAscii

readAscii

readAscii

readVariableLengthQuantity

writeVariableLengthQuantity

readByte

writeByte

readByte

writeByte

readInt8

writeInt8

readInt8

writeInt8

readUInt8

writeUInt8

readUInt8

writeUInt8

readBoolean

readBoolean

writeBoolean

writeBoolean

readChar

readChar

writeChar

writeChar

readShort

writeShort

readShort

writeShort

readInt

writeInt

readInt

writeInt

readLong

writeLong

readLong

writeLong

readFloat