* data[offset] = (byte)value;
*
* Added for consistency with other put~() methods
*/
public static void putByte(byte[] data, int offset, int value) {
putNumber(data, offset, value, LittleEndianConsts.BYTE_SIZE);
}
/**
* put a array of shorts into a byte array
*
*@param data the byte array
*@param offset a starting offset into the byte array
*@param value the short array
*/
public static void putShortArray(final byte[] data, final int offset, final short[] value) {
putNumber(data, offset, value.length, SHORT_SIZE);
for (int i = 0; i < value.length; i++) {
putNumber(data, offset + 2 + (i * 2), value[i], SHORT_SIZE);
}
}
/**
* put an unsigned short value into a byte array
*
* @param data the byte array
* @param offset a starting offset into the byte array
* @param value the short (16-bit) value
*
* @exception ArrayIndexOutOfBoundsException may be thrown
*/
public static void putUShort(final byte[] data, final int offset,
final int value)
{
putNumber(data, offset, value, SHORT_SIZE);
}
/**
* put a short value into beginning of a byte array
*
*@param data the byte array
*@param value the short (16-bit) value
*/
public static void putShort(final byte[] data, final short value) {
putShort(data, 0, value);
}
/**
* put an int value into a byte array
*
*@param data the byte array
*@param offset a starting offset into the byte array
*@param value the int (32-bit) value
*/
public static void putInt(final byte[] data, final int offset,
final int value) {
putNumber(data, offset, value, INT_SIZE);
}
/**
* put an int value into beginning of a byte array
*
*@param data the byte array
*@param value the int (32-bit) value
*/
public static void putInt(final byte[] data, final int value) {
putInt(data, 0, value);
}
/**
* put a long value into a byte array
*
*@param data the byte array
*@param offset a starting offset into the byte array
*@param value the long (64-bit) value
*/
public static void putLong(final byte[] data, final int offset,
final long value) {
putNumber(data, offset, value, LONG_SIZE);
}
/**
* put a long value into beginning of a byte array
*
*@param data the byte array
*@param value the long (64-bit) value
*/
public static void putLong(final byte[] data, final long value) {
putLong(data, 0, value);
}
/**
* put a double value into a byte array
*
*@param data the byte array
*@param offset a starting offset into the byte array
*@param value the double (64-bit) value
*/
public static void putDouble(final byte[] data, final int offset,
final double value) {
// Excel likes NaN to be a specific value.
if (Double.isNaN(value))
putNumber(data, offset, -276939487313920L, DOUBLE_SIZE);
else
putNumber(data, offset, Double.doubleToLongBits(value), DOUBLE_SIZE);
}
/**
* put a double value into beginning of a byte array
*
*@param data the byte array
*@param value the double (64-bit) value
*/
public static void putDouble(final byte[] data, final double value) {
putDouble(data, 0, value);
}
/**
* Exception to handle buffer underruns
*
*@author Marc Johnson (mjohnson at apache dot org)
*/
public static class BufferUnderrunException
extends IOException {
/**
* simple constructor
*/
BufferUnderrunException() {
super("buffer underrun");
}
}
/**
* get a short value from an InputStream
*
*@param stream the InputStream from which the short
* is to be read
*@return the short (16-bit) value
*@exception IOException will be propagated back to the caller
*@exception BufferUnderrunException if the stream cannot provide enough
* bytes
*/
public static short readShort(final InputStream stream)
throws IOException, BufferUnderrunException {
return getShort(readFromStream(stream, SHORT_SIZE));
}
/**
* get an int value from an InputStream
*
*@param stream the InputStream from which the int is
* to be read
*@return the int (32-bit) value
*@exception IOException will be propagated back to the caller
*@exception BufferUnderrunException if the stream cannot provide enough
* bytes
*/
public static int readInt(final InputStream stream)
throws IOException, BufferUnderrunException {
return getInt(readFromStream(stream, INT_SIZE));
}
/**
* get a long value from an InputStream
*
*@param stream the InputStream from which the long
* is to be read
*@return the long (64-bit) value
*@exception IOException will be propagated back to the caller
*@exception BufferUnderrunException if the stream cannot provide enough
* bytes
*/
public static long readLong(final InputStream stream)
throws IOException, BufferUnderrunException {
return getLong(readFromStream(stream, LONG_SIZE));
}
/**
* Read the appropriate number of bytes from the stream and return them to
* the caller. * * However, for the purposes of the POI project, this risk is deemed * negligible. It is, however, so noted. * *@param stream the InputStream we're reading from *@param size the number of bytes to read; in * 99.99% of cases, this will be SHORT_SIZE, INT_SIZE, or LONG_SIZE -- * but it doesn't have to be. *@return the byte array containing the * required number of bytes. The array will contain all zero's on end * of stream *@exception IOException will be propagated back to the caller *@exception BufferUnderrunException if the stream cannot provide enough * bytes */ public static byte[] readFromStream(final InputStream stream, final int size) throws IOException, BufferUnderrunException { byte[] buffer = new byte[size]; int count = stream.read(buffer); if (count == -1) { // return a zero-filled buffer Arrays.fill(buffer, (byte) 0); } else if (count != size) { throw new BufferUnderrunException(); } return buffer; } /** * Gets the number attribute of the LittleEndian class * *@param data Description of the Parameter *@param offset Description of the Parameter *@param size Description of the Parameter *@return The number value */ private static long getNumber(final byte[] data, final int offset, final int size) { long result = 0; for (int j = offset + size - 1; j >= offset; j--) { result <<= 8; result |= 0xff & data[j]; } return result; } /** * Description of the Method * *@param data Description of the Parameter *@param offset Description of the Parameter *@param value Description of the Parameter *@param size Description of the Parameter */ private static void putNumber(final byte[] data, final int offset, final long value, final int size) { int limit = size + offset; long v = value; for (int j = offset; j < limit; j++) { data[j] = (byte) (v & 0xFF); v >>= 8; } } /** * Convert an 'unsigned' byte to an integer. ie, don't carry across the * sign. * *@param b Description of the Parameter *@return Description of the Return Value */ public static int ubyteToInt(byte b) { return ((b & 0x80) == 0 ? (int) b : (b & (byte) 0x7f) + 0x80); } /** * get the unsigned value of a byte. * *@param data the byte array. *@param offset a starting offset into the byte array. *@return the unsigned value of the byte as a 32 bit integer */ public static int getUnsignedByte(final byte[] data, final int offset) { return (int) getNumber(data, offset, BYTE_SIZE); } /** * get the unsigned value of a byte. * *@param data the byte array *@return the unsigned value of the byte as a 32 bit integer */ public static int getUnsignedByte(final byte[] data) { return getUnsignedByte(data, 0); } /** * Copy a portion of a byte array * *@param data the original byte array *@param offset Where to start copying from. *@param size Number of bytes to copy. *@return The byteArray value *@throws IndexOutOfBoundsException - if copying would cause access of * data outside array bounds. */ public static byte[] getByteArray(final byte[] data, int offset, int size) { byte[] copy = new byte[size]; System.arraycopy(data, offset, copy, 0, size); return copy; } /** *
Gets an unsigned int value (8 bytes) from a byte array.
* * @param data the byte array * @param offset a starting offset into the byte array * @return the unsigned int (32-bit) value in a long */ public static long getULong(final byte[] data, final int offset) { int num = (int) getNumber(data, offset, LONG_SIZE); long retNum; if (num < 0) retNum = ((long) Integer.MAX_VALUE + 1) * 2 + num; else retNum = num; return retNum; } }