removed a debug

[lwes-java.git] / src / main / java / org / lwes / util / NumberCodec.java

/*======================================================================*
 * Copyright (c) 2008, Yahoo! Inc. All rights reserved.                 *
 *                                                                      *
 * Licensed under the New BSD License (the "License"); you may not use  *
 * this file except in compliance with the License.  Unless required    *
 * by applicable law or agreed to in writing, software distributed      *
 * under the License is distributed on an "AS IS" BASIS, WITHOUT        *
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.     *
 * See the License for the specific language governing permissions and  *
 * limitations under the License. See accompanying LICENSE file.        *
 *======================================================================*/

package org.lwes.util;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.math.BigInteger;

/**
 * This is a class to efficiently encode built-in primitive types into
 * byte arrays and decode them back.  While this can be done with a
 * combination of ByteArrayOutputStreams, DataOutputStreams,
 * ByteArrayInputStreams, DataInputStreams, merely creating those
 * objects is quite costly and it is difficult to make them persistent.
 * As such, this contains code lifted from the guts of the Data*Stream
 * classes.
 * <p/>
 * Also, this class defines functions to convert primitive types and
 * byte arrays to and from hexadecimal strings.
 * <p/>
 * Hopefully, support for these operations will be added to
 * the standard Java API and this class can be retired.
 *
 * @author Preston Pfarner
 * @author Michael P. Lum
 * @version %I%, %G%
 * @since 0.0.1
 */
public final class NumberCodec {
    private static transient Log log = LogFactory.getLog(NumberCodec.class);

    public static final int BYTE_BYTES = 1;
    public static final int SHORT_BYTES = 2;
    public static final int INT_BYTES = 4;
    public static final int LONG_BYTES = 8;

    public static final int BYTE_BITS = 8;
    public static final int SHORT_BITS = SHORT_BYTES * BYTE_BITS;
    public static final int INT_BITS = INT_BYTES * BYTE_BITS;
    public static final int LONG_BITS = LONG_BYTES * BYTE_BITS;

    public static final short BYTE_MASK = 0xFF;
    public static final int SHORT_MASK = 0xFFFF;
    public static final long INT_MASK = 0xFFFFFFFFL;

    private static final char[] hexCharMap = {
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
    };

    private static final byte[] hexByteMap = {
            (byte) '0', (byte) '1', (byte) '2', (byte) '3',
            (byte) '4', (byte) '5', (byte) '6', (byte) '7',
            (byte) '8', (byte) '9', (byte) 'A', (byte) 'B',
            (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F',
    };

    /**
     * Prohibited constructor; this is an uninstantiable class.
     */
    private NumberCodec() {
    }


    /* ***********************************************************************
      * ENCODING TO BYTE ARRAYS
      * ***********************************************************************/

    /**
     * Encode a byte into a byte-array buffer. <br>
     * This version does not perform any null or range checks!
     *
     * @param b      the byte to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     */
    public static void encodeByteUnchecked(byte b, byte[] buffer, int offset) {
        buffer[offset] = b;
    }

    /**
     * Encode a byte into a byte-array buffer.
     *
     * @param b      the byte to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     * @param length the maximum number of bytes that may be written
     */
    public static void encodeByte(byte b, byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(BYTE_BYTES, buffer, offset, length);
        encodeByteUnchecked(b, buffer, offset);
    }

    /**
     * Encode a short into a byte-array buffer. <br>
     * This version does not perform any null or range checks!
     *
     * @param s      the short to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     */
    public static void encodeShortUnchecked(short s, byte[] buffer, int offset) {
        buffer[offset++] = (byte) ((s >>> (1 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset] = (byte) ((s >>> (0 * BYTE_BITS)) & BYTE_MASK);
    }

    /**
     * Encode a short into a byte-array buffer.
     *
     * @param s      the short to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     * @param length the maximum number of bytes that may be written
     */
    public static void encodeShort(short s, byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(SHORT_BYTES, buffer, offset, length);
        encodeShortUnchecked(s, buffer, offset);
    }

    /**
     * Encode an int into a byte-array buffer. <br>
     * This version does not perform any null or range checks!
     *
     * @param i      the int to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     */
    public static void encodeIntUnchecked(int i, byte[] buffer, int offset) {
        buffer[offset++] = (byte) ((i >>> (3 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((i >>> (2 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((i >>> (1 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset] = (byte) ((i >>> (0 * BYTE_BITS)) & BYTE_MASK);
    }

    /**
     * Encode an int into a byte-array buffer.
     *
     * @param i      the int to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     * @param length the maximum number of bytes that may be written
     */
    public static void encodeInt(int i, byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(INT_BYTES, buffer, offset, length);
        encodeIntUnchecked(i, buffer, offset);
    }

    /**
     * Encode a long into a byte-array buffer.
     *
     * @param l      the long to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     */
    public static void encodeLongUnchecked(long l, byte[] buffer, int offset) {
        buffer[offset++] = (byte) ((l >>> (7 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((l >>> (6 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((l >>> (5 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((l >>> (4 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((l >>> (3 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((l >>> (2 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset++] = (byte) ((l >>> (1 * BYTE_BITS)) & BYTE_MASK);
        buffer[offset] = (byte) ((l >>> (0 * BYTE_BITS)) & BYTE_MASK);
    }

    /**
     * Encode a long into a byte-array buffer.
     *
     * @param l      the long to be encoded
     * @param buffer the byte array into which the encoding should be written
     * @param offset the position in the array to start writing the encoding
     * @param length the maximum number of bytes that may be written
     */
    public static void encodeLong(long l, byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(LONG_BYTES, buffer, offset, length);
        encodeLongUnchecked(l, buffer, offset);
    }

    /* ***********************************************************************
      * DECODING FROM BYTE ARRAYS
      * ***********************************************************************/

    /**
     * Extract and decode a byte out of a byte-array buffer. <br>
     * This version does not perform any null or range checks!
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     */
    public static final byte decodeByteUnchecked(byte[] buffer, int offset) {
        return buffer[offset];
    }

    /**
     * Decode a byte out of a byte-array buffer.
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     * @param length the maximum number of bytes that may be read
     */
    public static final byte decodeByte(byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(BYTE_BYTES, buffer, offset, length);
        return decodeByteUnchecked(buffer, offset);
    }

    /**
     * Extract and decode a short out of a byte-array buffer. <br>
     * This version does not perform any null or range checks!
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     */
    public static short decodeShortUnchecked(byte[] buffer, int offset) {
        return
                (short) ((decodeByteUnchecked(buffer, offset) << BYTE_BITS) +
                         (decodeByteUnchecked(buffer, offset + BYTE_BYTES) & BYTE_MASK));
    }

    /**
     * Decode a short out of a byte-array buffer.
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     * @param length the maximum number of bytes that may be read
     */
    public static short decodeShort(byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(SHORT_BYTES, buffer, offset, length);
        return decodeShortUnchecked(buffer, offset);
    }

    /**
     * Extract and decode an int out of a byte-array buffer. <br>
     * This version does not perform any null or range checks!
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     */
    public static int decodeIntUnchecked(byte[] buffer, int offset) {
        return ((decodeShortUnchecked(buffer, offset) << SHORT_BITS) +
                (decodeShortUnchecked(buffer, offset + SHORT_BYTES) & SHORT_MASK));
    }

    /**
     * Decode an int out of a byte-array buffer.
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     * @param length the maximum number of bytes that may be read
     */
    public static int decodeInt(byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(INT_BYTES, buffer, offset, length);
        return decodeIntUnchecked(buffer, offset);
    }

    /**
     * Extract and decode a long out of a byte-array buffer. <br>
     * This version does not perform any null or range checks!
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     */
    public static long decodeLongUnchecked(byte[] buffer, int offset) {
        return ((((long) decodeIntUnchecked(buffer, offset)) << INT_BITS) +
                (decodeIntUnchecked(buffer, offset + INT_BYTES) & INT_MASK));
    }

    /**
     * Decode a long out of a byte-array buffer.
     *
     * @param buffer the byte array from which the encoded form should be read
     * @param offset the position in the array to start reading the encoded form
     * @param length the maximum number of bytes that may be read
     */
    public static long decodeLong(byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        checkRange(LONG_BYTES, buffer, offset, length);
        return decodeLongUnchecked(buffer, offset);
    }

    /**
     * Verifies that the buffer exists, that the writeable region fits into
     * the buffer, and that the writeable length is long enough.
     *
     * @param minLength the length that will be written
     * @param buffer    the destination array
     * @param offset    the first position that should be written
     * @param length    the number of bytes that may be written
     * @throws IllegalArgumentException if the check fails
     */
    public static void checkRange(int minLength,
                                  byte[] buffer, int offset, int length)
            throws IllegalArgumentException {
        if (buffer == null) {
            throw new IllegalArgumentException("Buffer is null.");
        }
        if ((offset < 0) || (length < 0) || (offset + length > buffer.length)) {
            throw new IllegalArgumentException("Writeable region does not fit: " +
                                               offset + "," + length + "," + buffer.length);
        }
        if (minLength > length) {
            throw new IllegalArgumentException("Writeable region is too small: " +
                                               minLength + ">" + length);
        }
    }

    /* ***********************************************************************
      * WRITING TO STRINGS (IN HEX)
      * ***********************************************************************/

    /**
     * Output a number in unsigned hexadecimal form, padding with zeroes,
     * with a fixed result size.  Extra opening "f"'s are removed.
     *
     * @param num      the number to convert
     * @param numBytes the number of bytes to write (each is two hex digits)
     * @return a String representing the number.
     */
    private static String toHexString(long num, int numBytes) {
        final StringBuffer buf = new StringBuffer(2 * numBytes);
        writeHexString(num, numBytes, buf);
        return buf.toString();
    }

    /**
     * Write a number in unsigned hexadecimal form, padding with zeroes,
     * with a fixed result size.  Extra opening "f"'s are removed.
     *
     * @param num      the number to convert
     * @param numBytes the number of bytes to write (each is two hex digits)
     * @param buf      the StringBuffer into which to write
     */
    private static void writeHexString(long num, int numBytes, StringBuffer buf) {
        final int startLen = buf.length();
        int numNibbles = numBytes << 1;
        int pos = startLen + numNibbles;
        buf.setLength(pos);
        while (numNibbles != 0) {
            --pos;
            final byte masked = (byte) (num & 0xf);
            buf.setCharAt(pos, hexCharMap[masked]);
            num >>>= 4;
            --numNibbles;
        }
    }

    /**
     * Write a number in unsigned hexadecimal form, padding with zeroes,
     * with a fixed result size.  Extra opening "f"'s are removed.
     *
     * @param value    the number to convert
     * @param bytes    the byte array into which to write
     * @param offset   the offset into <code>bytes</code> to start
     * @param numBytes the number of bytes to write (each is two hex digits)
     */
    private static void writeHexString
            (long value, byte[] bytes, int offset, int numBytes) {
        int numNibbles = numBytes << 1;
        int pos = offset + numNibbles;
        while (numNibbles != 0) {
            --pos;
            final byte masked = (byte) (value & 0xf);
            bytes[pos] = hexByteMap[masked];
            value >>>= 4;
            --numNibbles;
        }
    }

    /* ***********************************************************************
      * Convert numbers to hex strings
      * ***********************************************************************/

    /**
     * Output a byte in unsigned hexadecimal form, padding with zeroes.
     *
     * @param b the byte
     * @return a String representing the byte.
     */
    public static String toHexString(byte b) {
        return toHexString(b, BYTE_BYTES);
    }

    /**
     * Output a short in unsigned hexadecimal form, padding with zeroes.
     *
     * @param s the short
     * @return a String representing the short.
     */
    public static String toHexString(short s) {
        return toHexString(s, SHORT_BYTES);
    }

    /**
     * Output an int in unsigned hexadecimal form, padding with zeroes.
     *
     * @param i the int
     * @return a String representing the int.
     */
    public static String toHexString(int i) {
        return toHexString(i, INT_BYTES);
    }

    /**
     * Output a long in unsigned hexadecimal form, padding with zeroes.
     *
     * @param l the long
     * @return a String representing the long.
     */
    public static String toHexString(long l) {
        return toHexString(l, LONG_BYTES);
    }

    /**
     * Output a BigInteger in unsigned hexadecimal form, padding with zeroes.
     *
     * @param bi the BigInteger
     * @return a String representing the BigInteger.
     */
    public static String toHexString(BigInteger bi) {
        if (bi == null) {
            return "";
        }
        return bi.toString(16); // 16-bit radix
    }

    /* ***********************************************************************
      * Write hex strings into string buffers
      * ***********************************************************************/

    /**
     * Write a byte in unsigned hexadecimal form, padding with zeroes.
     *
     * @param buf the StringBuffer into which to write
     * @param b   the byte
     */
    public static void writeHexString(byte b, StringBuffer buf) {
        writeHexString(b, BYTE_BYTES, buf);
    }

    /**
     * Write a short in unsigned hexadecimal form, padding with zeroes.
     *
     * @param buf the StringBuffer into which to write
     * @param s   the short
     */
    public static void writeHexString(short s, StringBuffer buf) {
        writeHexString(s, SHORT_BYTES, buf);
    }

    /**
     * Write a int in unsigned hexadecimal form, padding with zeroes.
     *
     * @param buf the StringBuffer into which to write
     * @param i   the int
     */
    public static void writeHexString(int i, StringBuffer buf) {
        writeHexString(i, INT_BYTES, buf);
    }

    /**
     * Write a long in unsigned hexadecimal form, padding with zeroes.
     *
     * @param buf the StringBuffer into which to write
     * @param l   the long
     */
    public static void writeHexString(long l, StringBuffer buf) {
        writeHexString(l, LONG_BYTES, buf);
    }

    /* ***********************************************************************
      * Write hex strings into byte arrays
      * (with each byte representing a nibble in ASCII)
      * ***********************************************************************/

    /**
     * Write a byte in unsigned hexadecimal form, padding with zeroes.
     *
     * @param b      the byte
     * @param bytes  the byte array into which to write
     * @param offset the index in the byte array to start writing
     */
    public static void writeHexString(byte b, byte[] bytes, int offset) {
        writeHexString(b, bytes, offset, BYTE_BYTES);
    }

    /**
     * Write a short in unsigned hexadecimal form, padding with zeroes.
     *
     * @param value  the value to write
     * @param bytes  the byte array into which to write
     * @param offset the index in the byte array to start writing
     */
    public static void writeHexString(short value, byte[] bytes, int offset) {
        writeHexString(value, bytes, offset, SHORT_BYTES);
    }

    /**
     * Write a int in unsigned hexadecimal form, padding with zeroes.
     *
     * @param value  the value to write
     * @param bytes  the byte array into which to write
     * @param offset the index in the byte array to start writing
     */
    public static void writeHexString(int value, byte[] bytes, int offset) {
        writeHexString(value, bytes, offset, INT_BYTES);
    }

    /**
     * Write a long in unsigned hexadecimal form, padding with zeroes.
     *
     * @param value  the value to write
     * @param bytes  the byte array into which to write
     * @param offset the index in the byte array to start writing
     */
    public static void writeHexString(long value, byte[] bytes, int offset) {
        writeHexString(value, bytes, offset, LONG_BYTES);
    }


    /**
     * Return a String encoding the bytes from a portion of a byte array
     * in hex form.
     *
     * @param bytes  the byte array
     * @param offset the first byte to output
     * @param length the number of bytes to output
     * @return the hex dump of the byte array
     */
    public static String byteArrayToHexString(byte[] bytes,
                                              int offset, int length) {
        StringBuffer buf = new StringBuffer(2 * length);
        for (int i = offset; i < offset + length; i++) {
            buf.append(Character.forDigit(((bytes[i] >>> 4) & 0x0f), 16));
            buf.append(Character.forDigit((bytes[i] & 0x0f), 16));
        }
        return buf.toString();
    }

    public static byte[] hexStringToByteArray(String aString) {
        int length = aString.length();
        if ((length % 2) != 0) {
            log.error("ERROR: Odd Number, can't convert to byte array");
            return null;
        }
        byte[] bytes = new byte[(length / 2)];
        for (int k = 0; k < (length / 2); k++) {
            bytes[k] = (byte) 0;
        }
        byte[] str_bytes = aString.getBytes();
        if (str_bytes.length != length) {
            log.error("ERROR: Mismatching lengths");
            return null;
        }
        int count = 0;
        boolean waitingForSecondNibble = false;
        for (int i = 0; i < length; i++) {
            switch (str_bytes[i]) {
                case ((byte) '0'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x0;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x0 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '1'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x1;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x1 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '2'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x2;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x2 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '3'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x3;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x3 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '4'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x4;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x4 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '5'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x5;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x5 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '6'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x6;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x6 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '7'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x7;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x7 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '8'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x8;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x8 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) '9'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0x9;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0x9 << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) 'a'):
                case ((byte) 'A'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0xa;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0xa << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) 'b'):
                case ((byte) 'B'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0xb;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0xb << 4);
                        waitingForSecondNibble = true;
                    }
                    break;
                case ((byte) 'c'):
                case ((byte) 'C'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0xc;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0xc << 4);
                        waitingForSecondNibble = true;
                    }
                    break;

                case ((byte) 'd'):
                case ((byte) 'D'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0xd;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0xd << 4);
                        waitingForSecondNibble = true;
                    }
                    break;

                case ((byte) 'e'):
                case ((byte) 'E'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0xe;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0xe << 4);
                        waitingForSecondNibble = true;
                    }
                    break;

                case ((byte) 'f'):
                case ((byte) 'F'):
                    if (waitingForSecondNibble) {
                        bytes[count] |= (byte) 0xf;
                        count++;
                        waitingForSecondNibble = false;
                    }
                    else {
                        bytes[count] |= (byte) ((byte) 0xf << 4);
                        waitingForSecondNibble = true;
                    }
                    break;

                default:
                    log.error("ERROR: non-hex character");
                    return null;
            }
        }
        return bytes;
    }

    /**
     * Return a String encoding the bytes in a byte array in hex form. <br>
     * This is equivalent to
     * <code>byteArrayToHexString(bytes,0,bytes.length);</code>
     *
     * @param bytes the byte array
     * @return the hex dump of the byte array
     */
    public static String byteArrayToHexString(byte[] bytes) {
        return byteArrayToHexString(bytes, 0, bytes.length);
    }

    /**
     * Turn an unsigned hex string into a long.  This whole thing is here
     * to replace Long.parseLong(str,16) because it fails with large unsigned
     * hex strings (ones that denote negative values).  When they work out
     * the signed hex vs. unsigned hex issue in the Java API, this can be
     * retired.
     *
     * @param str the String to parse
     * @return the long that was written in <code>str</code>
     */
    private static long fromHexString(String str, long min) {
        final int hex = 16;
        final char firstChar = str.charAt(0);
        final int digit = Character.digit(firstChar, hex);
        if (digit < hex / 2) {
            return Long.parseLong(str, hex);
        }
        else {
            /* Subtract <code>hex/2</code> from the first digit and flip the sign. */
            final String posStr = (Character.forDigit(digit - hex / 2, hex) +
                                   str.substring(1, str.length()));
            final long offsetLong = Long.parseLong(posStr, hex);
            return offsetLong + min;
        }
    }

    /**
     * Output a byte in unsigned hexadecimal form, padding with zeroes.
     *
     * @param s the String representing the byte.
     * @return the parsed byte
     */
    public static byte byteFromHexString(String s) {
        return (byte) fromHexString(s, Byte.MIN_VALUE);
    }

    /**
     * Output a short in unsigned hexadecimal form, padding with zeroes.
     *
     * @param s the String representing the short
     * @return the parsed short
     */
    public static short shortFromHexString(String s) {
        return (short) fromHexString(s, Short.MIN_VALUE);
    }

    /**
     * Output an int in unsigned hexadecimal form, padding with zeroes.
     *
     * @param s the String representing the int.
     * @return the parsed int
     */
    public static int intFromHexString(String s) {
        return (int) fromHexString(s, Integer.MIN_VALUE);
    }

    /**
     * Output a long in unsigned hexadecimal form, padding with zeroes.
     *
     * @param s the String representing the long.
     * @return the parsed long
     */
    public static long longFromHexString(String s) {
        return fromHexString(s, Long.MIN_VALUE);
    }

    /**
     * Decode a long out of a byte-array buffer. (convienience method)
     *
     * @param pBytes the byte array from which the encoded form should be read
     * @return long decoded from bytes
     */
    public static long decodeLong(byte[] pBytes)
            throws NumberFormatException {
        if (pBytes == null) {
            throw new NumberFormatException("null byte array passed");
        }
        if (pBytes.length != NumberCodec.LONG_BYTES) {
            throw new NumberFormatException("expecting byte array length of: " +
                                            NumberCodec.LONG_BYTES + " got: " + pBytes.length);
        }
        return NumberCodec.decodeLong(pBytes, 0, pBytes.length);
    }

    /**
     * Encode a long into a byte-array buffer. (convienience method)
     *
     * @param pLong the long to be encoded
     * @return encoded bytes of the long
     */
    public static byte[] encodeLong(long pLong) {
        byte[] bytes = new byte[NumberCodec.LONG_BYTES];
        NumberCodec.encodeLong(pLong, bytes, 0, bytes.length);
        return bytes;
    }

    /**
     * Decode a int out of a byte-array buffer. (convienience method)
     *
     * @param pBytes the byte array from which the encoded form should be read
     * @return int decoded from bytes
     */
        public static int decodeInt (byte[] pBytes)
        throws NumberFormatException
        {
                if (pBytes == null)
                {
                        throw new NumberFormatException("null byte array passed");
                }
                if (pBytes.length != NumberCodec.LONG_BYTES)
                {
                        throw new NumberFormatException("expecting byte array length of: " +
                                        NumberCodec.INT_BYTES + " got: " + pBytes.length);
                }
                return NumberCodec.decodeInt(pBytes, 0, pBytes.length);
        }

        /**
     * Encode a int into a byte-array buffer. (convienience method)
     *
     * @param pInt the int to be encoded
     * @return encoded bytes of the int
     */
        public static byte[] encodeInt (int pInt)
        throws NumberFormatException
        {
                byte[] bytes = new byte[NumberCodec.INT_BYTES];
                NumberCodec.encodeInt(pInt, bytes, 0, bytes.length);
                return bytes;
        }
}