Add bit switch feature

Author: patrickfav

CHANGELOG

@@ -4,6 +4,7 @@
 
 * better type hierarchy with read-only and mutable types
 * add validator feature
+* add bit switch feature
 
 ## v0.2.0
 

src/main/java/at/favre/lib/bytes/Bytes.java

@@ -689,6 +689,17 @@ public Bytes resize(int newByteLength) {
         return transform(new BytesTransformer.ResizeTransformer(newByteLength));
     }
 
+    /**
+     * Returns a Byte whose value is equivalent to this Byte with the designated bit switched to newBitValue. Bits start to count from the LSB (ie. Bytes.from(0).switchBit(0,true) == 1)
+     *
+     * @param bitPosition not to confuse with byte position
+     * @param newBitValue if true set to 1, 0 otherwise
+     * @return instance with bit switched
+     */
+    public Bytes switchBit(int bitPosition, boolean newBitValue) {
+        return transform(new BytesTransformer.BitSwitchTransformer(bitPosition, newBitValue));
+    }
+
     /**
      * Generic transformation of this instance.
      * <p>

src/main/java/at/favre/lib/bytes/BytesTransformer.java

@@ -284,4 +284,35 @@ public byte[] transform(byte[] currentArray, boolean inPlace) {
             return resizedArray;
         }
     }
+
+    /**
+     * Switches bits on specific position of an array
+     */
+    class BitSwitchTransformer implements BytesTransformer {
+        private final int position;
+        private final boolean newBitValue;
+
+        BitSwitchTransformer(int position, boolean newBitValue) {
+            this.position = position;
+            this.newBitValue = newBitValue;
+        }
+
+        @Override
+        public byte[] transform(byte[] currentArray, boolean inPlace) {
+            byte[] out = inPlace ? currentArray : Bytes.from(currentArray).array();
+
+            if (position < 0 || position >= 8 * currentArray.length) {
+                throw new IllegalArgumentException("bit index " + (position * 8) + " out of bounds");
+            }
+
+
+            int bytePosition = currentArray.length - 1 - position / 8;
+            if (newBitValue) {
+                out[bytePosition] ^= (1 << position % 8);
+            } else {
+                out[bytePosition] &= ~(1 << position % 8);
+            }
+            return out;
+        }
+    }
 }

src/test/java/at/favre/lib/bytes/BytesTransformTest.java

@@ -23,6 +23,7 @@
 
 import org.junit.Test;
 
+import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.security.SecureRandom;
 import java.util.Comparator;
@@ -241,6 +242,22 @@ public void rightShift() throws Exception {
         assertArrayEquals(new byte[1], Bytes.from(example_bytes_two).rightShift(16).array());
     }
 
+    @Test
+    public void bitSwitch() throws Exception {
+        assertEquals(1, Bytes.from(0).switchBit(0, true).toInt());
+
+        for (int i = 0; i < 63; i++) {
+            for (long j = 1; j < 33; j++) {
+                assertEquals("bit position " + i + " is wrong",
+                        BigInteger.valueOf(j).flipBit(i).longValue(),
+                        Bytes.from(j).switchBit(i, true).toLong());
+                assertEquals("bit position " + i + " is wrong",
+                        BigInteger.valueOf(j).clearBit(i).longValue(),
+                        Bytes.from(j).switchBit(i, false).toLong());
+            }
+        }
+    }
+
     @Test
     public void transform() throws Exception {
         assertArrayEquals(example_bytes_two, Bytes.from(example_bytes_two).transform(new BytesTransformer() {