[calcite] branch master updated: [CALCITE-3714] BitString.createFromBytes reverses order of the bits in each byte

[jhyde]

This is an automated email from the ASF dual-hosted git repository.

jhyde pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/calcite.git


The following commit(s) were added to refs/heads/master by this push:
     new 8555e1b  [CALCITE-3714] BitString.createFromBytes reverses order of 
the bits in each byte
8555e1b is described below

commit 8555e1bc14f0e94a2f1c1e25d56c1a04341e432e
Author: Julian Hyde <jh...@apache.org>
AuthorDate: Mon Jan 6 19:10:46 2020 -0800

    [CALCITE-3714] BitString.createFromBytes reverses order of the bits in each 
byte
    
    Also, implement hashCode and equals in BitString.
---
 .../java/org/apache/calcite/util/BitString.java    | 22 ++++++++++++++++-----
 .../java/org/apache/calcite/util/UtilTest.java     | 23 +++++++++++++++++-----
 2 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/core/src/main/java/org/apache/calcite/util/BitString.java 
b/core/src/main/java/org/apache/calcite/util/BitString.java
index d715097..f523826 100644
--- a/core/src/main/java/org/apache/calcite/util/BitString.java
+++ b/core/src/main/java/org/apache/calcite/util/BitString.java
@@ -18,6 +18,7 @@ package org.apache.calcite.util;
 
 import java.math.BigInteger;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * String of bits.
@@ -90,6 +91,17 @@ public class BitString {
     return toBitString();
   }
 
+  @Override public int hashCode() {
+    return bits.hashCode() + bitCount;
+  }
+
+  @Override public boolean equals(Object o) {
+    return o == this
+        || o instanceof BitString
+        && bits.equals(((BitString) o).bits)
+        && bitCount == ((BitString) o).bitCount;
+  }
+
   public int getBitCount() {
     return bitCount;
   }
@@ -192,14 +204,14 @@ public class BitString {
    * @return BitString
    */
   public static BitString createFromBytes(byte[] bytes) {
-    assert bytes != null;
-    int bitCount = bytes.length * 8;
+    int bitCount = Objects.requireNonNull(bytes).length * 8;
     StringBuilder sb = new StringBuilder(bitCount);
     for (byte b : bytes) {
-      for (int i = 7; i >= 0; --i) {
-        sb.append(((b & 1) == 0) ? '0' : '1');
-        b >>= 1;
+      final String s = Integer.toBinaryString(Byte.toUnsignedInt(b));
+      for (int i = s.length(); i < 8; i++) {
+        sb.append('0'); // pad to length 8
       }
+      sb.append(s);
     }
     return new BitString(sb.toString(), bitCount);
   }
diff --git a/core/src/test/java/org/apache/calcite/util/UtilTest.java 
b/core/src/test/java/org/apache/calcite/util/UtilTest.java
index 3fc4ac3..b853f67 100644
--- a/core/src/test/java/org/apache/calcite/util/UtilTest.java
+++ b/core/src/test/java/org/apache/calcite/util/UtilTest.java
@@ -90,7 +90,6 @@ import java.util.function.Function;
 import java.util.function.ObjIntConsumer;
 
 import static org.apache.calcite.test.Matchers.isLinux;
-import static org.apache.calcite.util.BitString.createFromBitString;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.instanceOf;
@@ -334,13 +333,27 @@ public class UtilTest {
     assertReversible("01");
     assertReversible("001010");
     assertReversible("000000000100");
+
+    // from bytes
+    final byte[] b255 = {(byte) 0xFF};
+    assertThat(BitString.createFromBytes(b255).toString(),
+        is("11111111"));
+    final byte[] b11 = {(byte) 0x0B};
+    assertThat(BitString.createFromBytes(b11).toString(),
+        is("00001011"));
+    final byte[] b011 = {(byte) 0x00, 0x0B};
+    assertThat(BitString.createFromBytes(b011).toString(),
+        is("0000000000001011"));
   }
 
   private static void assertReversible(String s) {
-    assertEquals(createFromBitString(s).toBitString(), s, s);
-    assertEquals(
-        s,
-        BitString.createFromHexString(s).toHexString());
+    final BitString bitString = BitString.createFromBitString(s);
+    assertThat(bitString.toBitString(), is(s));
+    assertThat(BitString.createFromHexString(s).toHexString(), is(s));
+
+    final BitString bitString8 =
+        BitString.createFromBytes(bitString.getAsByteArray());
+    assertThat(bitString8.getAsByteArray(), is(bitString.getAsByteArray()));
   }
 
   private void assertByteArray(