littleendian.java

这是一款基于PlaceLab软件开发的导航系统中间件的客户端程序.

     *
     * @param data the byte array
     * @param value the int (32-bit) value
     *
     * @exception ArrayIndexOutOfBoundsException may be thrown
     */

    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
     *
     * @exception ArrayIndexOutOfBoundsException may be thrown
     */

    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
     *
     * @exception ArrayIndexOutOfBoundsException may be thrown
     */

    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
     *
     * @exception ArrayIndexOutOfBoundsException may be thrown
     */

    public static void putDouble(final byte[] data, final int offset,
                                 final double value)
    {
        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
     *
     * @exception ArrayIndexOutOfBoundsException may be thrown
     */

    public static void putDouble(final byte[] data, final double value)
    {
        putDouble(data, 0, value);
    }

    /**
     * Exception to handle buffer underruns
     *
     * 
     */

    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));
    }

    private static final byte[] _short_buffer = new byte[SHORT_SIZE];
    private static final byte[] _int_buffer = new byte[INT_SIZE];
    private static final byte[] _long_buffer = new byte[LONG_SIZE];

    /**
     * Read the appropriate number of bytes from the stream and return
     * them to the caller.
     * <p>
     * It should be noted that, in an attempt to improve system
     * performance and to prevent a transient explosion of discarded
     * byte arrays to be garbage collected, static byte arrays are
     * employed for the standard cases of reading a short, an int, or
     * a long.
     * <p>
     * <b>THIS INTRODUCES A RISK FOR THREADED OPERATIONS!</b>
     * <p>
     * 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 = null;

        switch (size)
        {

            case SHORT_SIZE:
                buffer = _short_buffer;
                break;

            case INT_SIZE:
                buffer = _int_buffer;
                break;

            case LONG_SIZE:
                buffer = _long_buffer;
                break;

            default :
                buffer = new byte[size];
                break;
        }
        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;
    }

    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;
    }

    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.
     */
    public static int ubyteToInt(byte b)
    {
        return ((b & 0x80) == 0 ? (int) b : (int) (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
     *
     * @exception ArrayIndexOutOfBoundsException may be thrown
     */
    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
     *
     * @exception ArrayIndexOutOfBoundsException may be thrown
     */
    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.
     *
     * @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;
    }

    /**
     * Retrieves and unsigned short.  This is converted UP to a int
     * so it can fit.
     *
     * @param data      The data to read
     * @param offset    The offset to read the short from
     * @return An integer representation of the short.
     */
    public static int getUShort( byte[] data, int offset )
    {
        return (int)getNumber(data, offset, SHORT_SIZE);
    }

}