/**
* Returns the first byte from the byte array
- * @param byte[] data
* @return byte value
*/
public static byte getByte(byte[] data) {
/**
* Returns the short value for the byte array passed.
* Size of byte array is restricted to Short.SIZE
- * @param byte[] data
* @return short value
*/
public static short getShort(byte[] data) {
/**
* Returns the int value for the byte array passed.
* Size of byte array is restricted to Integer.SIZE
- * @param byte[] data
* @return int - the integer value of byte array
*/
public static int getInt(byte[] data) {
/**
* Returns the long value for the byte array passed.
* Size of byte array is restricted to Long.SIZE
- * @param byte[] data
* @return long - the integer value of byte array
*/
public static long getLong(byte[] data) {
logger.error("", e);
}
}
- return (long) toNumber(data);
+ return toNumber(data);
}
/**
* Returns the short value for the last numBits of the byte array passed.
* Size of numBits is restricted to Short.SIZE
- * @param byte[] data
- * @param int - numBits
* @return short - the short value of byte array
*/
public static short getShort(byte[] data, int numBits) {
/**
* Returns the int value for the last numBits of the byte array passed.
* Size of numBits is restricted to Integer.SIZE
- * @param byte[] data
- * @param int - numBits
* @return int - the integer value of byte array
*/
public static int getInt(byte[] data, int numBits) {
/**
* Returns the long value for the last numBits of the byte array passed.
* Size of numBits is restricted to Long.SIZE
- * @param byte[] data
- * @param int - numBits
* @return long - the integer value of byte array
*/
public static long getLong(byte[] data, int numBits) {
} catch (BufferException e) {
logger.error("", e);
}
- return (long) toNumber(bits, numBits);
+ return toNumber(bits, numBits);
}
/**
* 0101000010 | 0000101 | 1111001010010101011
* will be returned as {0,0,0,0,0,1,0,1}
*
- * @param byte[] data
- * @param int startOffset - offset to start fetching bits from data from
- * @param int numBits - number of bits to be fetched from data
+ * @param startOffset - offset to start fetching bits from data from
+ * @param numBits - number of bits to be fetched from data
* @return byte [] - LSB aligned bits
*
* @throws BufferException
return bytes;
} else {
System.arraycopy(data, startByteOffset, bytes, 0, numBytes - 1);
- bytes[numBytes - 1] = (byte) ((int) data[startByteOffset
+ bytes[numBytes - 1] = (byte) (data[startByteOffset
+ numBytes - 1] & getMSBMask(extranumBits));
}
} else {
/**
* Bits are expected to be stored in the input byte array from LSB
- * @param byte[] - data to set the input byte
- * @param byte - input byte to be inserted
- * @param startOffset - offset of data[] to start inserting byte from
- * @param numBits - number of bits of input to be inserted into data[]
+ * @param data to set the input byte
+ * @param input byte to be inserted
+ * @param startOffset offset of data[] to start inserting byte from
+ * @param numBits number of bits of input to be inserted into data[]
*
* @throws BufferException
* when the input, startOffset and numBits are not congruent
/**
* Bits are expected to be stored in the input byte array from LSB
- * @param byte[] - data to set the input byte
- * @param byte[] - input bytes to be inserted
- * @param startOffset - offset of data[] to start inserting byte from
- * @param numBits - number of bits of input to be inserted into data[]
- * @return void
+ * @param data to set the input byte
+ * @param input bytes to be inserted
+ * @param startOffset offset of data[] to start inserting byte from
+ * @param numBits number of bits of input to be inserted into data[]
* @throws BufferException
* when the startOffset and numBits parameters are not congruent
* with data and input buffers' size
/**
* Returns numBits 1's in the MSB position
- *
- * @param numBits
- * @return
*/
public static int getMSBMask(int numBits) {
int mask = 0;
/**
* Returns numBits 1's in the LSB position
- *
- * @param numBits
- * @return
*/
public static int getLSBMask(int numBits) {
int mask = 0;
/**
* Returns the numerical value of the byte array passed
*
- * @param byte[] - array
* @return long - numerical value of byte array passed
*/
static public long toNumber(byte[] array) {
value += 256;
}
ret = ret
- | (long) ((long) value << ((length - i - 1) * NetUtils.NumBitsInAByte));
+ | (long) value << ((length - i - 1) * NetUtils.NumBitsInAByte);
}
return ret;
}
* Returns the numerical value of the last numBits (LSB bits) of the byte
* array passed
*
- * @param byte[] - array
- * @param int - numBits
* @return long - numerical value of byte array passed
*/
static public long toNumber(byte[] array, int numBits) {
value += 256;
}
ret = ret
- | (long) ((long) value << ((array.length - i - 1) * NetUtils.NumBitsInAByte));
+ | (long) value << ((array.length - i - 1) * NetUtils.NumBitsInAByte);
}
return ret;
* Accepts a number as input and returns its value in byte form in LSB
* aligned form example: input = 5000 [1001110001000] bytes = 19, -120
* [00010011] [10001000]
- *
- * @param Number
- * @return byte[]
- *
*/
-
public static byte[] toByteArray(Number input) {
Class<? extends Number> dataType = input.getClass();
short size = 0;
* aligned form example: input = 5000 [1001110001000] bytes = -114, 64
* [10011100] [01000000]
*
- * @param Number
- * input
- * @param int numBits - the number of bits to be returned
+ * @param numBits - the number of bits to be returned
* @return byte[]
*
*/
/**
* Takes an LSB aligned byte array and returned the LSB numBits in a MSB
- * aligned byte array
- *
- * @param inputbytes
- * @param numBits
- * @return
- */
- /**
+ * aligned byte array.
+ * <p>
* It aligns the last numBits bits to the head of the byte array following
* them with numBits % 8 zero bits.
*
* Example: For inputbytes = [00000111][01110001] and numBits = 12 it
* returns: shiftedBytes = [01110111][00010000]
*
- * @param byte[] inputBytes
- * @param int numBits - number of bits to be left aligned
+ * @param numBits - number of bits to be left aligned
* @return byte[]
*/
public static byte[] shiftBitsToMSB(byte[] inputBytes, int numBits) {
* Example: For inputbytes = [01110111][00010000] and numBits = 12 it
* returns: shiftedBytes = [00000111][01110001]
*
- * @param byte[] inputBytes
- * @param int numBits - number of bits to be right aligned
+ * @param inputBytes
+ * @param numBits - number of bits to be right aligned
* @return byte[]
*/
public static byte[] shiftBitsToLSB(byte[] inputBytes, int numBits) {
* Insert in the data buffer at position dictated by the offset the number
* of bits specified from the input data byte array. The input byte array
* has the bits stored starting from the LSB
- *
- * @param byte[] data
- * @param byte[] inputdata
- * @param int startOffset
- * @param int numBits
*/
public static void insertBits(byte[] data, byte[] inputdataLSB,
int startOffset, int numBits) {
/**
* Checks for overflow and underflow exceptions
- * @param data
- * @param startOffset
- * @param numBits
- * @throws PacketException when the startOffset and numBits parameters
+ * @throws BufferException when the startOffset and numBits parameters
* are not congruent with the data buffer's size
*/
public static void checkExceptions(byte[] data, int startOffset, int numBits)
Code Review / controller.git / blobdiff