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

©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.