added returnAccumulatedForBitReadInEof flag into JBBPBitInputStream to change default behaviour for missing bit data part in the end of a stream

Author: raydac

jbbp/src/main/java/com/igormaznitsa/jbbp/io/JBBPBitInputStream.java

@@ -40,6 +40,11 @@ public class JBBPBitInputStream extends FilterInputStream implements JBBPCountab
    */
   protected static final int INITIAL_ARRAY_BUFFER_SIZE =
       JBBPSystemProperty.PROPERTY_INPUT_INITIAL_ARRAY_BUFFER_SIZE.getAsInteger(32);
+  /**
+   * Allow return accumulated data during met end of stream and missing part of bits field data.
+   * @since 3.1.0
+   */
+  private final boolean returnAccumulatedForBitReadInEof;
   /**
    * Contains bit mode for bit operations.
    */
@@ -68,7 +73,6 @@ public class JBBPBitInputStream extends FilterInputStream implements JBBPCountab
    * Internal temp variable to keep the byte counter temporarily.
    */
   private long markedByteCounter;
-
   /**
    * Internal flag shows that read stopped for whole stream array read limit reach.
    *
@@ -77,48 +81,84 @@ public class JBBPBitInputStream extends FilterInputStream implements JBBPCountab
   private boolean detectedArrayLimit;
 
   /**
-   * Flag shows that read of array was stopped for array limiter restrictions.
-   *
-   * @return true if array limiter restrictions detected, false otherwise
-   * @see JBBPArraySizeLimiter
-   * @since 2.1.0
-   */
-  public boolean isDetectedArrayLimit() {
-    return this.detectedArrayLimit;
-  }
-
-  /**
-   * Set value for array limit detected flag. It is important to set the flag for correct processing of parsing.
+   * A Constructor, the LSB0 bit order will be used by default.
+   * <b>By default, if missing part of bit field in the end of stream then current accumulated data will be returned.</b>
    *
-   * @param value true or false.
-   * @see com.igormaznitsa.jbbp.JBBPParser
-   * @since 2.1.0
+   * @param in an input stream to be filtered.
    */
-  public void setDetectedArrayLimit(final boolean value) {
-    this.detectedArrayLimit = value;
+  public JBBPBitInputStream(final InputStream in) {
+    this(in, JBBPBitOrder.LSB0);
   }
 
   /**
    * A Constructor, the LSB0 bit order will be used by default.
    *
-   * @param in an input stream to be filtered.
+   * @param in                               an input stream to be filtered.
+   * @param returnAccumulatedForBitReadInEof if true then end of stream during bit read and some data missing returns accumulated data.
    */
-  public JBBPBitInputStream(final InputStream in) {
-    this(in, JBBPBitOrder.LSB0);
+  public JBBPBitInputStream(final InputStream in, final boolean returnAccumulatedForBitReadInEof) {
+    this(in, JBBPBitOrder.LSB0, returnAccumulatedForBitReadInEof);
   }
 
   /**
    * A Constructor.
+   * <b>By default, if missing part of bit field in the end of stream then current accumulated data will be returned.</b>
    *
    * @param in    an input stream to be filtered.
    * @param order a bit order mode for the filter.
    * @see JBBPBitOrder#LSB0
    * @see JBBPBitOrder#MSB0
    */
   public JBBPBitInputStream(final InputStream in, final JBBPBitOrder order) {
+    this(in, order, true);
+  }
+
+  /**
+   * Create wrapping bit input stream.
+   *
+   * @param in                               the base input stream, must not be null
+   * @param order                            a bit order mode for the filter.
+   * @param returnAccumulatedForBitReadInEof if true then end of stream during bit read and some data missing returns accumulated data.
+   * @since 3.1.0
+   */
+  public JBBPBitInputStream(final InputStream in, final JBBPBitOrder order,
+                            final boolean returnAccumulatedForBitReadInEof) {
     super(in);
     this.bitsInBuffer = 0;
     this.bitOrderMode = order;
+    this.returnAccumulatedForBitReadInEof = returnAccumulatedForBitReadInEof;
+  }
+
+  /**
+   * If true then the bit stream returns currently accumulated data for bit read if end of stream and not whole bit data read, -1 otherwise.
+   *
+   * @return boolean flag for the behavior, true if allowed
+   * @since 3.1.0
+   */
+  public boolean isReturnAccumulatedForBitReadInEof() {
+    return this.returnAccumulatedForBitReadInEof;
+  }
+
+  /**
+   * Flag shows that read of array was stopped for array limiter restrictions.
+   *
+   * @return true if array limiter restrictions detected, false otherwise
+   * @see JBBPArraySizeLimiter
+   * @since 2.1.0
+   */
+  public boolean isDetectedArrayLimit() {
+    return this.detectedArrayLimit;
+  }
+
+  /**
+   * Set value for array limit detected flag. It is important to set the flag for correct processing of parsing.
+   *
+   * @param value true or false.
+   * @see com.igormaznitsa.jbbp.JBBPParser
+   * @since 2.1.0
+   */
+  public void setDetectedArrayLimit(final boolean value) {
+    this.detectedArrayLimit = value;
   }
 
   /**
@@ -198,7 +238,7 @@ public boolean[] readBoolArray(final int items,
 
   @Override
   public int read(final byte[] array, final int offset, final int length) throws IOException {
-    return this.read(array, offset, length, true);
+    return this.read(array, offset, length, this.returnAccumulatedForBitReadInEof);
   }
 
   /**
@@ -210,13 +250,13 @@ public int read(final byte[] array, final int offset, final int length) throws I
    * @param array                     target array
    * @param offset                    offset in the target array
    * @param length                    the length of data portion to be read
-   * @param allowEofForMissingBitData if true then allow to stop read if missing data for non-complete read bits operation.
+   * @param returnAccumulatedForBitReadInEof if true then return accumulated data if end of stream during bit read, return -1 otherwise.
    * @return number of read bytes from the wrapped input stream
    * @throws IOException thrown if any transport error
-   * @since 3.0.1
+   * @since 3.1.0
    */
   public int read(final byte[] array, final int offset, final int length,
-                  final boolean allowEofForMissingBitData) throws IOException {
+                  final boolean returnAccumulatedForBitReadInEof) throws IOException {
     if (this.bitsInBuffer == 0) {
       int readBytes = 0;
       int tempOffset = offset;
@@ -248,7 +288,7 @@ public int read(final byte[] array, final int offset, final int length,
       int count = length;
       int i = offset;
       while (count > 0) {
-        final int nextByte = this.readBits(JBBPBitNumber.BITS_8, allowEofForMissingBitData);
+        final int nextByte = this.readBits(JBBPBitNumber.BITS_8, returnAccumulatedForBitReadInEof);
         if (nextByte < 0) {
           break;
         }
@@ -383,7 +423,7 @@ private byte[] internalReadArray(
       byte[] buffer = new byte[INITIAL_ARRAY_BUFFER_SIZE];
       // till end
       while (true) {
-        final int next = readByteArray ? read() : this.readBits(bitNumber, true);
+        final int next = readByteArray ? read() : this.readBits(bitNumber, this.returnAccumulatedForBitReadInEof);
         if (next < 0) {
           break;
         }
@@ -415,7 +455,7 @@ private byte[] internalReadArray(
         }
       } else {
         for (int i = 0; i < items; i++) {
-          final int next = this.readBits(bitNumber, true);
+          final int next = this.readBits(bitNumber, this.returnAccumulatedForBitReadInEof);
           if (next < 0) {
             throw new EOFException("Have read only " + i + " bit portions instead of " + items);
           }
@@ -951,7 +991,7 @@ public JBBPBitOrder getBitOrder() {
    * @since 1.3.0
    */
   public byte readBitField(final JBBPBitNumber numOfBitsToRead) throws IOException {
-    final int value = this.readBits(numOfBitsToRead, true);
+    final int value = this.readBits(numOfBitsToRead, this.returnAccumulatedForBitReadInEof);
     if (value < 0) {
       throw new EOFException("Can't read bits from stream [" + numOfBitsToRead + ']');
     }
@@ -971,7 +1011,7 @@ public byte readBitField(final JBBPBitNumber numOfBitsToRead) throws IOException
    * @throws NullPointerException if number of bits to be read is null
    */
   public int readBits(final JBBPBitNumber numOfBitsToRead) throws IOException {
-    return this.readBits(numOfBitsToRead, false);
+    return this.readBits(numOfBitsToRead, this.returnAccumulatedForBitReadInEof);
   }
 
   /**
@@ -980,13 +1020,13 @@ public int readBits(final JBBPBitNumber numOfBitsToRead) throws IOException {
    * Behaviour in case of missing bit data can be tuned by the special argument flag and if it is true then -1 returned otherwise current accumulated bit data returned.
    *
    * @param numOfBitsToRead           the number of bits to be read, must be 1..8
-   * @param allowEofForMissingBitData if false then returned current accumulated data as stream ended with missing bits, -1 otherwise
+   * @param returnAccumulatedForBitReadInEof if false then returned current accumulated data as stream ended with missing bits, -1 otherwise
    * @return the read bits as integer, -1 if the end of stream has been reached or if allowed end of stream flag and not all bits read.
    * @throws IOException          it will be thrown for transport errors to be read
    * @throws NullPointerException if number of bits to be read is null
    * @since 3.0.1
    */
-  public int readBits(final JBBPBitNumber numOfBitsToRead, final boolean allowEofForMissingBitData)
+  public int readBits(final JBBPBitNumber numOfBitsToRead, final boolean returnAccumulatedForBitReadInEof)
       throws IOException {
     int result;
 
@@ -1028,12 +1068,12 @@ public int readBits(final JBBPBitNumber numOfBitsToRead, final boolean allowEofF
               if (i == numOfBitsAsNumber) {
                 return nextByte;
               } else {
-                if (allowEofForMissingBitData) {
+                if (returnAccumulatedForBitReadInEof) {
+                  break;
+                } else {
                   this.bitBuffer = 0;
                   this.bitsInBuffer = 0;
                   return -1;
-                } else {
-                  break;
                 }
               }
             } else {
@@ -1058,12 +1098,12 @@ public int readBits(final JBBPBitNumber numOfBitsToRead, final boolean allowEofF
               if (i == numOfBitsAsNumber) {
                 return nextByte;
               } else {
-                if (allowEofForMissingBitData) {
+                if (returnAccumulatedForBitReadInEof) {
+                  break;
+                } else {
                   this.bitBuffer = 0;
                   this.bitsInBuffer = 0;
                   return -1;
-                } else {
-                  break;
                 }
               }
             } else {

jbbp/src/test/java/com/igormaznitsa/jbbp/io/JBBPBitInputStreamTest.java

@@ -1614,9 +1614,10 @@ public void testReadBooleanArray_WholeStream() throws Exception {
   }
 
   @Test
-  public void testReadNotFullByteArrayAfterBitReading() throws Exception {
+  public void testReadNotFullByteArrayAfterBitReading_disableAccumulatedBitsOnEof()
+      throws Exception {
     final JBBPBitInputStream in = new JBBPBitInputStream(
-        new ByteArrayInputStream(str2bin("00010010_00110100_01010110_11011101")));
+        new ByteArrayInputStream(str2bin("00010010_00110100_01010110_11011101")), false);
     assertEquals(0x2, in.readBits(BITS_4));
     assertEquals(0, in.getCounter());
 
@@ -1634,10 +1635,11 @@ public void testReadNotFullByteArrayAfterBitReading() throws Exception {
   }
 
   @Test
-  public void testReadNotFullByteArrayAfterBitReading_MSB0() throws Exception {
+  public void testReadNotFullByteArrayAfterBitReading_MSB0_disableAccumulatedBitsOnEof()
+      throws Exception {
     final JBBPBitInputStream in = new JBBPBitInputStream(
         new ByteArrayInputStream(str2bin("00010010_00110100_01010110_11011101")),
-        JBBPBitOrder.MSB0);
+        JBBPBitOrder.MSB0, false);
     assertEquals(0x8, in.readBits(BITS_4));
     assertEquals(0, in.getCounter());
 
@@ -1655,31 +1657,31 @@ public void testReadNotFullByteArrayAfterBitReading_MSB0() throws Exception {
   }
 
   @Test
-  public void testReadNotFullByteArrayAfterBitReading_disableEofForMissingBitData()
+  public void testReadNotFullByteArrayAfterBitReading()
       throws Exception {
     final JBBPBitInputStream in = new JBBPBitInputStream(
         new ByteArrayInputStream(new byte[] {(byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0xDD}));
     assertEquals(0x2, in.readBits(BITS_4));
     assertEquals(0, in.getCounter());
 
     final byte[] readarray = new byte[6];
-    final int read = in.read(readarray, 0, readarray.length, false);
+    final int read = in.read(readarray, 0, readarray.length, true);
     assertEquals(4, read);
     assertEquals(4, in.getCounter());
     assertArrayEquals(new byte[] {(byte) 0x41, (byte) 0x63, (byte) 0xD5, (byte) 0x0D, 0, 0},
         readarray);
   }
 
   @Test
-  public void testReadNotFullByteArrayAfterBitReading_MSB0_disableEofForMissingBitData()
+  public void testReadNotFullByteArrayAfterBitReading_MSB0()
       throws Exception {
     final JBBPBitInputStream in = new JBBPBitInputStream(
         new ByteArrayInputStream(new byte[] {(byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0xDD}),
         JBBPBitOrder.MSB0);
     assertEquals(0x8, in.readBits(BITS_4));
 
     final byte[] readarray = new byte[6];
-    final int read = in.read(readarray, 0, readarray.length, false);
+    final int read = in.read(readarray, 0, readarray.length);
 
     assertEquals(4, read);
     assertEquals(4, in.getCounter());