Another attack on integrating encoder and decoder: Version is done. Attempted to...

[zxing.git] / core / src / com / google / zxing / qrcode / encoder / BitVector.java

diff --git a/core/src/com/google/zxing/qrcode/encoder/BitVector.java b/core/src/com/google/zxing/qrcode/encoder/BitVector.java
index 82512bc..a78078b 100644 (file)
--- a/core/src/com/google/zxing/qrcode/encoder/BitVector.java
+++ b/core/src/com/google/zxing/qrcode/encoder/BitVector.java
@@ -38,11 +38,11 @@ public final class BitVector {
   }
 
   // Return the bit value at "index".
-  public int at(final int index) {
+  public int at(int index) {
     if (index < 0 || index >= sizeInBits) {
       throw new IllegalArgumentException("Bad index: " + index);
     }
-    final int value = array[index >> 3] & 0xff;
+    int value = array[index >> 3] & 0xff;
     return (value >> (7 - (index & 0x7))) & 1;
   }
 
@@ -52,62 +52,62 @@ public final class BitVector {
   }
 
   // Return the number of bytes in the bit vector.
-  public int num_bytes() {
+  public int sizeInBytes() {
     return (sizeInBits + 7) >> 3;
   }
 
   // Append one bit to the bit vector.
-  public void AppendBit(final int bit) {
+  public void appendBit(int bit) {
     if (!(bit == 0 || bit == 1)) {
       throw new IllegalArgumentException("Bad bit");
     }
-    final int num_bits_in_last_byte = sizeInBits & 0x7;
+    int numBitsInLastByte = sizeInBits & 0x7;
     // We'll expand array if we don't have bits in the last byte.
-    if (num_bits_in_last_byte == 0) {
+    if (numBitsInLastByte == 0) {
       appendByte(0);
       sizeInBits -= 8;
     }
     // Modify the last byte.
-    array[sizeInBits >> 3] |= (bit << (7 - num_bits_in_last_byte));
+    array[sizeInBits >> 3] |= (bit << (7 - numBitsInLastByte));
     ++sizeInBits;
   }
 
-  // Append "num_bits" bits in "value" to the bit vector.
-  // REQUIRES: 0<= num_bits <= 32.
+  // Append "numBits" bits in "value" to the bit vector.
+  // REQUIRES: 0<= numBits <= 32.
   //
   // Examples:
-  // - AppendBits(0x00, 1) adds 0.
-  // - AppendBits(0x00, 4) adds 0000.
-  // - AppendBits(0xff, 8) adds 11111111.
-  public void AppendBits(final int value, final int num_bits) {
-    if (num_bits < 0 || num_bits > 32) {
+  // - appendBits(0x00, 1) adds 0.
+  // - appendBits(0x00, 4) adds 0000.
+  // - appendBits(0xff, 8) adds 11111111.
+  public void appendBits(int value, int numBits) {
+    if (numBits < 0 || numBits > 32) {
       throw new IllegalArgumentException("Num bits must be between 0 and 32");
     }
-    int num_bits_left = num_bits;
-    while (num_bits_left > 0) {
+    int numBitsLeft = numBits;
+    while (numBitsLeft > 0) {
       // Optimization for byte-oriented appending.
-      if ((sizeInBits & 0x7) == 0 && num_bits_left >= 8) {
-        final int newByte = (value >> (num_bits_left - 8)) & 0xff;
+      if ((sizeInBits & 0x7) == 0 && numBitsLeft >= 8) {
+        int newByte = (value >> (numBitsLeft - 8)) & 0xff;
         appendByte(newByte);
-        num_bits_left -= 8;
+        numBitsLeft -= 8;
       } else {
-        final int bit = (value >> (num_bits_left - 1)) & 1;
-        AppendBit(bit);
-        --num_bits_left;
+        int bit = (value >> (numBitsLeft - 1)) & 1;
+        appendBit(bit);
+        --numBitsLeft;
       }
     }
   }
 
   // Append "bits".
-  public void AppendBitVector(final BitVector bits) {
+  public void appendBitVector(BitVector bits) {
     int size = bits.size();
     for (int i = 0; i < size; ++i) {
-      AppendBit(bits.at(i));
+      appendBit(bits.at(i));
     }
   }
 
   // Modify the bit vector by XOR'ing with "other"
-  public void XOR(final BitVector other) {
+  public void xor(BitVector other) {
     if (sizeInBits != other.size()) {
       throw new IllegalArgumentException("BitVector sizes don't match");
     }
@@ -124,9 +124,9 @@ public final class BitVector {
     StringBuffer result = new StringBuffer(sizeInBits);
     for (int i = 0; i < sizeInBits; ++i) {
       if (at(i) == 0) {
-        result.append("0");
+        result.append('0');
       } else if (at(i) == 1) {
-        result.append("1");
+        result.append('1');
       } else {
         throw new IllegalArgumentException("Byte isn't 0 or 1");
       }
@@ -144,7 +144,7 @@ public final class BitVector {
   // run out of room.
   private void appendByte(int value) {
     if ((sizeInBits >> 3) == array.length) {
-      byte[] newArray = new byte[array.length * 2];
+      byte[] newArray = new byte[(array.length << 1)];
       System.arraycopy(array, 0, newArray, 0, array.length);
       array = newArray;
     }