Replace logger and log by LOG
[controller.git] / opendaylight / commons / liblldp / src / main / java / org / opendaylight / controller / liblldp / BitBufferHelper.java
1 /*
2  * Copyright (c) 2013, 2017 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8
9 /**
10  *
11  */
12 package org.opendaylight.controller.liblldp;
13
14 import java.util.Arrays;
15
16 import org.slf4j.Logger;
17 import org.slf4j.LoggerFactory;
18
19 /**
20  * BitBufferHelper class that provides utility methods to - fetch specific bits
21  * from a serialized stream of bits - convert bits to primitive data type - like
22  * short, int, long - store bits in specified location in stream of bits -
23  * convert primitive data types to stream of bits.
24  */
25 public abstract class BitBufferHelper {
26     protected static final Logger LOG = LoggerFactory.getLogger(BitBufferHelper.class);
27
28     public static final long ByteMask = 0xFF;
29
30     // Getters
31     // data: array where data are stored
32     // startOffset: bit from where to start reading
33     // numBits: number of bits to read
34     // All this function return an exception if overflow or underflow
35
36     /**
37      * Returns the first byte from the byte array.
38      *
39      * @return byte value
40      */
41     public static byte getByte(final byte[] data) {
42         if (data.length * NetUtils.NumBitsInAByte > Byte.SIZE) {
43             try {
44                 throw new BufferException("Container is too small for the number of requested bits");
45             } catch (final BufferException e) {
46                 LOG.error("", e);
47             }
48         }
49         return data[0];
50     }
51
52     /**
53      * Returns the short value for the byte array passed. Size of byte array is
54      * restricted to Short.SIZE
55      *
56      * @return short value
57      */
58     public static short getShort(final byte[] data) {
59         if (data.length > Short.SIZE) {
60             try {
61                 throw new BufferException("Container is too small for the number of requested bits");
62             } catch (final BufferException e) {
63                 LOG.error("", e);
64             }
65         }
66         return (short) toNumber(data);
67     }
68
69     /**
70      * Returns the int value for the byte array passed. Size of byte array is
71      * restricted to Integer.SIZE
72      *
73      * @return int - the integer value of byte array
74      */
75     public static int getInt(final byte[] data) {
76         if (data.length > Integer.SIZE) {
77             try {
78                 throw new BufferException("Container is too small for the number of requested bits");
79             } catch (final BufferException e) {
80                 LOG.error("", e);
81             }
82         }
83         return (int) toNumber(data);
84     }
85
86     /**
87      * Returns the long value for the byte array passed. Size of byte array is
88      * restricted to Long.SIZE
89      *
90      * @return long - the integer value of byte array
91      */
92     public static long getLong(final byte[] data) {
93         if (data.length > Long.SIZE) {
94             try {
95                 throw new BufferException("Container is too small for the number of requested bits");
96             } catch (final Exception e) {
97                 LOG.error("", e);
98             }
99         }
100         return toNumber(data);
101     }
102
103     /**
104      * Returns the short value for the last numBits of the byte array passed.
105      * Size of numBits is restricted to Short.SIZE
106      *
107      * @return short - the short value of byte array
108      */
109     public static short getShort(final byte[] data, final int numBits) {
110         if (numBits > Short.SIZE) {
111             try {
112                 throw new BufferException("Container is too small for the number of requested bits");
113             } catch (final BufferException e) {
114                 LOG.error("", e);
115             }
116         }
117         int startOffset = data.length * NetUtils.NumBitsInAByte - numBits;
118         byte[] bits = null;
119         try {
120             bits = BitBufferHelper.getBits(data, startOffset, numBits);
121         } catch (final BufferException e) {
122             LOG.error("", e);
123         }
124         return (short) toNumber(bits, numBits);
125     }
126
127     /**
128      * Returns the int value for the last numBits of the byte array passed. Size
129      * of numBits is restricted to Integer.SIZE
130      *
131      * @return int - the integer value of byte array
132      */
133     public static int getInt(final byte[] data, final int numBits) {
134         if (numBits > Integer.SIZE) {
135             try {
136                 throw new BufferException("Container is too small for the number of requested bits");
137             } catch (final BufferException e) {
138                 LOG.error("", e);
139             }
140         }
141         int startOffset = data.length * NetUtils.NumBitsInAByte - numBits;
142         byte[] bits = null;
143         try {
144             bits = BitBufferHelper.getBits(data, startOffset, numBits);
145         } catch (final BufferException e) {
146             LOG.error("", e);
147         }
148         return (int) toNumber(bits, numBits);
149     }
150
151     /**
152      * Returns the long value for the last numBits of the byte array passed.
153      * Size of numBits is restricted to Long.SIZE
154      *
155      * @return long - the integer value of byte array
156      */
157     public static long getLong(final byte[] data, final int numBits) {
158         if (numBits > Long.SIZE) {
159             try {
160                 throw new BufferException("Container is too small for the number of requested bits");
161             } catch (final BufferException e) {
162                 LOG.error("", e);
163             }
164         }
165         if (numBits > data.length * NetUtils.NumBitsInAByte) {
166             try {
167                 throw new BufferException("Trying to read more bits than contained in the data buffer");
168             } catch (final BufferException e) {
169                 LOG.error("", e);
170             }
171         }
172         int startOffset = data.length * NetUtils.NumBitsInAByte - numBits;
173         byte[] bits = null;
174         try {
175             bits = BitBufferHelper.getBits(data, startOffset, numBits);
176         } catch (final BufferException e) {
177             LOG.error("", e);
178         }
179         return toNumber(bits, numBits);
180     }
181
182     /**
183      * Reads the specified number of bits from the passed byte array starting to
184      * read from the specified offset The bits read are stored in a byte array
185      * which size is dictated by the number of bits to be stored. The bits are
186      * stored in the byte array LSB aligned.
187      *
188      * Ex. Read 7 bits at offset 10 0 9 10 16 17 0101000010 | 0000101 |
189      * 1111001010010101011 will be returned as {0,0,0,0,0,1,0,1}
190      *
191      * @param startOffset
192      *            - offset to start fetching bits from data from
193      * @param numBits
194      *            - number of bits to be fetched from data
195      * @return byte [] - LSB aligned bits
196      *
197      * @throws BufferException
198      *             when the startOffset and numBits parameters are not congruent
199      *             with the data buffer size
200      */
201     public static byte[] getBits(final byte[] data, final int startOffset, final int numBits) throws BufferException {
202         int startByteOffset = 0;
203         int valfromcurr, valfromnext;
204         int extranumBits = numBits % NetUtils.NumBitsInAByte;
205         int extraOffsetBits = startOffset % NetUtils.NumBitsInAByte;
206         int numBytes = numBits % NetUtils.NumBitsInAByte != 0 ? 1 + numBits / NetUtils.NumBitsInAByte
207                 : numBits / NetUtils.NumBitsInAByte;
208         byte[] shiftedBytes = new byte[numBytes];
209         startByteOffset = startOffset / NetUtils.NumBitsInAByte;
210         byte[] bytes = new byte[numBytes];
211         if (numBits == 0) {
212             return bytes;
213         }
214
215         checkExceptions(data, startOffset, numBits);
216
217         if (extraOffsetBits == 0) {
218             if (extranumBits == 0) {
219                 System.arraycopy(data, startByteOffset, bytes, 0, numBytes);
220                 return bytes;
221             } else {
222                 System.arraycopy(data, startByteOffset, bytes, 0, numBytes - 1);
223                 bytes[numBytes - 1] = (byte) (data[startByteOffset + numBytes - 1] & getMSBMask(extranumBits));
224             }
225         } else {
226             int i;
227             for (i = 0; i < numBits / NetUtils.NumBitsInAByte; i++) {
228                 // Reading numBytes starting from offset
229                 valfromcurr = data[startByteOffset + i] & getLSBMask(NetUtils.NumBitsInAByte - extraOffsetBits);
230                 valfromnext = data[startByteOffset + i + 1] & getMSBMask(extraOffsetBits);
231                 bytes[i] = (byte) (valfromcurr << extraOffsetBits
232                         | valfromnext >> NetUtils.NumBitsInAByte - extraOffsetBits);
233             }
234             // Now adding the rest of the bits if any
235             if (extranumBits != 0) {
236                 if (extranumBits < NetUtils.NumBitsInAByte - extraOffsetBits) {
237                     valfromnext = (byte) (data[startByteOffset + i] & getMSBMask(extranumBits) >> extraOffsetBits);
238                     bytes[i] = (byte) (valfromnext << extraOffsetBits);
239                 } else if (extranumBits == NetUtils.NumBitsInAByte - extraOffsetBits) {
240                     valfromcurr = data[startByteOffset + i] & getLSBMask(NetUtils.NumBitsInAByte - extraOffsetBits);
241                     bytes[i] = (byte) (valfromcurr << extraOffsetBits);
242                 } else {
243                     valfromcurr = data[startByteOffset + i] & getLSBMask(NetUtils.NumBitsInAByte - extraOffsetBits);
244                     valfromnext = data[startByteOffset + i + 1]
245                             & getMSBMask(extranumBits - (NetUtils.NumBitsInAByte - extraOffsetBits));
246                     bytes[i] = (byte) (valfromcurr << extraOffsetBits
247                             | valfromnext >> NetUtils.NumBitsInAByte - extraOffsetBits);
248                 }
249
250             }
251         }
252         // Aligns the bits to LSB
253         shiftedBytes = shiftBitsToLSB(bytes, numBits);
254         return shiftedBytes;
255     }
256
257     // Setters
258     // data: array where data will be stored
259     // input: the data that need to be stored in the data array
260     // startOffset: bit from where to start writing
261     // numBits: number of bits to read
262
263     /**
264      * Bits are expected to be stored in the input byte array from LSB
265      *
266      * @param data
267      *            to set the input byte
268      * @param input
269      *            byte to be inserted
270      * @param startOffset
271      *            offset of data[] to start inserting byte from
272      * @param numBits
273      *            number of bits of input to be inserted into data[]
274      *
275      * @throws BufferException
276      *             when the input, startOffset and numBits are not congruent
277      *             with the data buffer size
278      */
279     public static void setByte(final byte[] data, final byte input, final int startOffset, final int numBits)
280             throws BufferException {
281         byte[] inputByteArray = new byte[1];
282         Arrays.fill(inputByteArray, 0, 1, input);
283         setBytes(data, inputByteArray, startOffset, numBits);
284     }
285
286     /**
287      * Bits are expected to be stored in the input byte array from LSB
288      *
289      * @param data
290      *            to set the input byte
291      * @param input
292      *            bytes to be inserted
293      * @param startOffset
294      *            offset of data[] to start inserting byte from
295      * @param numBits
296      *            number of bits of input to be inserted into data[]
297      * @throws BufferException
298      *             when the startOffset and numBits parameters are not congruent
299      *             with data and input buffers' size
300      */
301     public static void setBytes(final byte[] data, final byte[] input, final int startOffset, final int numBits)
302             throws BufferException {
303         checkExceptions(data, startOffset, numBits);
304         insertBits(data, input, startOffset, numBits);
305     }
306
307     /**
308      * Returns numBits 1's in the MSB position
309      */
310     public static int getMSBMask(final int numBits) {
311         int mask = 0;
312         for (int i = 0; i < numBits; i++) {
313             mask = mask | 1 << 7 - i;
314         }
315         return mask;
316     }
317
318     /**
319      * Returns numBits 1's in the LSB position
320      */
321     public static int getLSBMask(final int numBits) {
322         int mask = 0;
323         for (int i = 0; i < numBits; i++) {
324             mask = mask | 1 << i;
325         }
326         return mask;
327     }
328
329     /**
330      * Returns the numerical value of the byte array passed
331      *
332      * @return long - numerical value of byte array passed
333      */
334     static public long toNumber(final byte[] array) {
335         long ret = 0;
336         long length = array.length;
337         int value = 0;
338         for (int i = 0; i < length; i++) {
339             value = array[i];
340             if (value < 0) {
341                 value += 256;
342             }
343             ret = ret | (long) value << (length - i - 1) * NetUtils.NumBitsInAByte;
344         }
345         return ret;
346     }
347
348     /**
349      * Returns the numerical value of the last numBits (LSB bits) of the byte
350      * array passed
351      *
352      * @return long - numerical value of byte array passed
353      */
354     static public long toNumber(final byte[] array, final int numBits) {
355         int length = numBits / NetUtils.NumBitsInAByte;
356         int bitsRest = numBits % NetUtils.NumBitsInAByte;
357         int startOffset = array.length - length;
358         long ret = 0;
359         int value = 0;
360
361         value = array[startOffset - 1] & getLSBMask(bitsRest);
362         value = array[startOffset - 1] < 0 ? array[startOffset - 1] + 256 : array[startOffset - 1];
363         ret = ret | value << (array.length - startOffset) * NetUtils.NumBitsInAByte;
364
365         for (int i = startOffset; i < array.length; i++) {
366             value = array[i];
367             if (value < 0) {
368                 value += 256;
369             }
370             ret = ret | (long) value << (array.length - i - 1) * NetUtils.NumBitsInAByte;
371         }
372
373         return ret;
374     }
375
376     /**
377      * Accepts a number as input and returns its value in byte form in LSB
378      * aligned form example: input = 5000 [1001110001000] bytes = 19, -120
379      * [00010011] [10001000]
380      */
381     public static byte[] toByteArray(final Number input) {
382         Class<? extends Number> dataType = input.getClass();
383         short size = 0;
384         long longValue = input.longValue();
385
386         if (dataType == Byte.class || dataType == byte.class) {
387             size = Byte.SIZE;
388         } else if (dataType == Short.class || dataType == short.class) {
389             size = Short.SIZE;
390         } else if (dataType == Integer.class || dataType == int.class) {
391             size = Integer.SIZE;
392         } else if (dataType == Long.class || dataType == long.class) {
393             size = Long.SIZE;
394         } else {
395             throw new IllegalArgumentException("Parameter must one of the following: Short/Int/Long\n");
396         }
397
398         int length = size / NetUtils.NumBitsInAByte;
399         byte bytes[] = new byte[length];
400
401         // Getting the bytes from input value
402         for (int i = 0; i < length; i++) {
403             bytes[i] = (byte) (longValue >> NetUtils.NumBitsInAByte * (length - i - 1) & ByteMask);
404         }
405         return bytes;
406     }
407
408     /**
409      * Accepts a number as input and returns its value in byte form in MSB
410      * aligned form example: input = 5000 [1001110001000] bytes = -114, 64
411      * [10011100] [01000000]
412      *
413      * @param numBits
414      *            - the number of bits to be returned
415      * @return byte[]
416      *
417      */
418     public static byte[] toByteArray(final Number input, final int numBits) {
419         Class<? extends Number> dataType = input.getClass();
420         short size = 0;
421         long longValue = input.longValue();
422
423         if (dataType == Short.class) {
424             size = Short.SIZE;
425         } else if (dataType == Integer.class) {
426             size = Integer.SIZE;
427         } else if (dataType == Long.class) {
428             size = Long.SIZE;
429         } else {
430             throw new IllegalArgumentException("Parameter must one of the following: Short/Int/Long\n");
431         }
432
433         int length = size / NetUtils.NumBitsInAByte;
434         byte bytes[] = new byte[length];
435         byte[] inputbytes = new byte[length];
436         byte shiftedBytes[];
437
438         // Getting the bytes from input value
439         for (int i = 0; i < length; i++) {
440             bytes[i] = (byte) (longValue >> NetUtils.NumBitsInAByte * (length - i - 1) & ByteMask);
441         }
442
443         if (bytes[0] == 0 && dataType == Long.class || bytes[0] == 0 && dataType == Integer.class) {
444             int index = 0;
445             for (index = 0; index < length; ++index) {
446                 if (bytes[index] != 0) {
447                     bytes[0] = bytes[index];
448                     break;
449                 }
450             }
451             System.arraycopy(bytes, index, inputbytes, 0, length - index);
452             Arrays.fill(bytes, length - index + 1, length - 1, (byte) 0);
453         } else {
454             System.arraycopy(bytes, 0, inputbytes, 0, length);
455         }
456
457         shiftedBytes = shiftBitsToMSB(inputbytes, numBits);
458
459         return shiftedBytes;
460     }
461
462     /**
463      * Takes an LSB aligned byte array and returned the LSB numBits in a MSB
464      * aligned byte array.
465      * <p>
466      * It aligns the last numBits bits to the head of the byte array following
467      * them with numBits % 8 zero bits.
468      *
469      * Example: For inputbytes = [00000111][01110001] and numBits = 12 it
470      * returns: shiftedBytes = [01110111][00010000]
471      *
472      * @param numBits
473      *            - number of bits to be left aligned
474      * @return byte[]
475      */
476     public static byte[] shiftBitsToMSB(final byte[] inputBytes, final int numBits) {
477         int numBitstoShiftBy = 0, leadZeroesMSB = 8, numEndRestBits = 0;
478         int size = inputBytes.length;
479         byte[] shiftedBytes = new byte[size];
480         int i;
481
482         for (i = 0; i < Byte.SIZE; i++) {
483             if ((byte) (inputBytes[0] & getMSBMask(i + 1)) != 0) {
484                 leadZeroesMSB = i;
485                 break;
486             }
487         }
488
489         if (numBits % NetUtils.NumBitsInAByte == 0) {
490             numBitstoShiftBy = 0;
491         } else {
492             numBitstoShiftBy = NetUtils.NumBitsInAByte - numBits % NetUtils.NumBitsInAByte < leadZeroesMSB
493                     ? NetUtils.NumBitsInAByte - numBits % NetUtils.NumBitsInAByte : leadZeroesMSB;
494         }
495         if (numBitstoShiftBy == 0) {
496             return inputBytes;
497         }
498
499         if (numBits < NetUtils.NumBitsInAByte) {
500             // inputbytes.length = 1 OR read less than a byte
501             shiftedBytes[0] = (byte) ((inputBytes[0] & getLSBMask(numBits)) << numBitstoShiftBy);
502         } else {
503             // # of bits to read from last byte
504             numEndRestBits = NetUtils.NumBitsInAByte
505                     - (inputBytes.length * NetUtils.NumBitsInAByte - numBits - numBitstoShiftBy);
506
507             for (i = 0; i < size - 1; i++) {
508                 if (i + 1 == size - 1) {
509                     if (numEndRestBits > numBitstoShiftBy) {
510                         shiftedBytes[i] = (byte) (inputBytes[i] << numBitstoShiftBy
511                                 | (inputBytes[i + 1] & getMSBMask(numBitstoShiftBy)) >> numEndRestBits
512                                         - numBitstoShiftBy);
513                         shiftedBytes[i + 1] = (byte) ((inputBytes[i + 1]
514                                 & getLSBMask(numEndRestBits - numBitstoShiftBy)) << numBitstoShiftBy);
515                     } else {
516                         shiftedBytes[i] = (byte) (inputBytes[i] << numBitstoShiftBy
517                                 | (inputBytes[i + 1] & getMSBMask(numEndRestBits)) >> NetUtils.NumBitsInAByte
518                                         - numEndRestBits);
519                     }
520                 }
521                 shiftedBytes[i] = (byte) (inputBytes[i] << numBitstoShiftBy
522                         | (inputBytes[i + 1] & getMSBMask(numBitstoShiftBy)) >> NetUtils.NumBitsInAByte
523                                 - numBitstoShiftBy);
524             }
525
526         }
527         return shiftedBytes;
528     }
529
530     /**
531      * It aligns the first numBits bits to the right end of the byte array
532      * preceding them with numBits % 8 zero bits.
533      *
534      * Example: For inputbytes = [01110111][00010000] and numBits = 12 it
535      * returns: shiftedBytes = [00000111][01110001]
536      *
537      * @param inputBytes
538      * @param numBits
539      *            - number of bits to be right aligned
540      * @return byte[]
541      */
542     public static byte[] shiftBitsToLSB(final byte[] inputBytes, final int numBits) {
543         int numBytes = inputBytes.length;
544         int numBitstoShift = numBits % NetUtils.NumBitsInAByte;
545         byte[] shiftedBytes = new byte[numBytes];
546         int inputLsb = 0, inputMsb = 0;
547
548         if (numBitstoShift == 0) {
549             return inputBytes;
550         }
551
552         for (int i = 1; i < numBytes; i++) {
553             inputLsb = inputBytes[i - 1] & getLSBMask(NetUtils.NumBitsInAByte - numBitstoShift);
554             inputLsb = inputLsb < 0 ? inputLsb + 256 : inputLsb;
555             inputMsb = inputBytes[i] & getMSBMask(numBitstoShift);
556             inputMsb = inputBytes[i] < 0 ? inputBytes[i] + 256 : inputBytes[i];
557             shiftedBytes[i] = (byte) (inputLsb << numBitstoShift
558                     | inputMsb >> NetUtils.NumBitsInAByte - numBitstoShift);
559         }
560         inputMsb = inputBytes[0] & getMSBMask(numBitstoShift);
561         inputMsb = inputMsb < 0 ? inputMsb + 256 : inputMsb;
562         shiftedBytes[0] = (byte) (inputMsb >> NetUtils.NumBitsInAByte - numBitstoShift);
563         return shiftedBytes;
564     }
565
566     /**
567      * Insert in the data buffer at position dictated by the offset the number
568      * of bits specified from the input data byte array. The input byte array
569      * has the bits stored starting from the LSB
570      */
571     public static void insertBits(final byte[] data, final byte[] inputdataLSB, final int startOffset,
572             final int numBits) {
573         byte[] inputdata = shiftBitsToMSB(inputdataLSB, numBits); // Align to
574                                                                     // MSB the
575                                                                     // passed
576                                                                     // byte
577                                                                     // array
578         int numBytes = numBits / NetUtils.NumBitsInAByte;
579         int startByteOffset = startOffset / NetUtils.NumBitsInAByte;
580         int extraOffsetBits = startOffset % NetUtils.NumBitsInAByte;
581         int extranumBits = numBits % NetUtils.NumBitsInAByte;
582         int RestBits = numBits % NetUtils.NumBitsInAByte;
583         int InputMSBbits = 0, InputLSBbits = 0;
584         int i;
585
586         if (numBits == 0) {
587             return;
588         }
589
590         if (extraOffsetBits == 0) {
591             if (extranumBits == 0) {
592                 numBytes = numBits / NetUtils.NumBitsInAByte;
593                 System.arraycopy(inputdata, 0, data, startByteOffset, numBytes);
594             } else {
595                 System.arraycopy(inputdata, 0, data, startByteOffset, numBytes);
596                 data[startByteOffset + numBytes] = (byte) (data[startByteOffset + numBytes]
597                         | inputdata[numBytes] & getMSBMask(extranumBits));
598             }
599         } else {
600             for (i = 0; i < numBytes; i++) {
601                 if (i != 0) {
602                     InputLSBbits = inputdata[i - 1] & getLSBMask(extraOffsetBits);
603                 }
604                 InputMSBbits = (byte) (inputdata[i] & getMSBMask(NetUtils.NumBitsInAByte - extraOffsetBits));
605                 InputMSBbits = InputMSBbits >= 0 ? InputMSBbits : InputMSBbits + 256;
606                 data[startByteOffset + i] = (byte) (data[startByteOffset + i]
607                         | InputLSBbits << NetUtils.NumBitsInAByte - extraOffsetBits | InputMSBbits >> extraOffsetBits);
608                 InputMSBbits = InputLSBbits = 0;
609             }
610             if (RestBits < NetUtils.NumBitsInAByte - extraOffsetBits) {
611                 if (numBytes != 0) {
612                     InputLSBbits = inputdata[i - 1] & getLSBMask(extraOffsetBits);
613                 }
614                 InputMSBbits = (byte) (inputdata[i] & getMSBMask(RestBits));
615                 InputMSBbits = InputMSBbits >= 0 ? InputMSBbits : InputMSBbits + 256;
616                 data[startByteOffset + i] = (byte) (data[startByteOffset + i]
617                         | InputLSBbits << NetUtils.NumBitsInAByte - extraOffsetBits | InputMSBbits >> extraOffsetBits);
618             } else if (RestBits == NetUtils.NumBitsInAByte - extraOffsetBits) {
619                 if (numBytes != 0) {
620                     InputLSBbits = inputdata[i - 1] & getLSBMask(extraOffsetBits);
621                 }
622                 InputMSBbits = (byte) (inputdata[i] & getMSBMask(NetUtils.NumBitsInAByte - extraOffsetBits));
623                 InputMSBbits = InputMSBbits >= 0 ? InputMSBbits : InputMSBbits + 256;
624                 data[startByteOffset + i] = (byte) (data[startByteOffset + i]
625                         | InputLSBbits << NetUtils.NumBitsInAByte - extraOffsetBits | InputMSBbits >> extraOffsetBits);
626             } else {
627                 if (numBytes != 0) {
628                     InputLSBbits = inputdata[i - 1] & getLSBMask(extraOffsetBits);
629                 }
630                 InputMSBbits = (byte) (inputdata[i] & getMSBMask(NetUtils.NumBitsInAByte - extraOffsetBits));
631                 InputMSBbits = InputMSBbits >= 0 ? InputMSBbits : InputMSBbits + 256;
632                 data[startByteOffset + i] = (byte) (data[startByteOffset + i]
633                         | InputLSBbits << NetUtils.NumBitsInAByte - extraOffsetBits | InputMSBbits >> extraOffsetBits);
634
635                 InputLSBbits = inputdata[i]
636                         & getLSBMask(RestBits - (NetUtils.NumBitsInAByte - extraOffsetBits)) << NetUtils.NumBitsInAByte
637                                 - RestBits;
638                 data[startByteOffset + i + 1] = (byte) (data[startByteOffset + i + 1]
639                         | InputLSBbits << NetUtils.NumBitsInAByte - extraOffsetBits);
640             }
641         }
642     }
643
644     /**
645      * Checks for overflow and underflow exceptions
646      *
647      * @throws BufferException
648      *             when the startOffset and numBits parameters are not congruent
649      *             with the data buffer's size
650      */
651     public static void checkExceptions(final byte[] data, final int startOffset, final int numBits)
652             throws BufferException {
653         int endOffsetByte;
654         int startByteOffset;
655         endOffsetByte = startOffset / NetUtils.NumBitsInAByte + numBits / NetUtils.NumBitsInAByte
656                 + (numBits % NetUtils.NumBitsInAByte != 0 ? 1 : startOffset % NetUtils.NumBitsInAByte != 0 ? 1 : 0);
657         startByteOffset = startOffset / NetUtils.NumBitsInAByte;
658
659         if (data == null) {
660             throw new BufferException("data[] is null\n");
661         }
662
663         if (startOffset < 0 || startByteOffset >= data.length || endOffsetByte > data.length || numBits < 0
664                 || numBits > NetUtils.NumBitsInAByte * data.length) {
665             throw new BufferException("Illegal arguement/out of bound exception - data.length = " + data.length
666                     + " startOffset = " + startOffset + " numBits " + numBits);
667         }
668     }
669 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.