4.x perf optimizations

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/base64/AbstractBase64UrlEncoder.java

@@ -1,5 +1,7 @@
 package com.iab.gpp.encoder.base64;
 
+import java.util.Arrays;
+import com.iab.gpp.encoder.bitstring.BitSet;
 import com.iab.gpp.encoder.bitstring.BitString;
 import com.iab.gpp.encoder.bitstring.BitStringBuilder;
 import com.iab.gpp.encoder.datatype.encoder.FixedIntegerEncoder;
@@ -11,18 +13,22 @@ public abstract class AbstractBase64UrlEncoder {
   protected abstract void pad(BitStringBuilder bitString);
 
   private static final int BASE64_BITS = 6;
+  private static final int NO_SYMBOL = -1;
   /**
    * Base 64 URL character set. Different from standard Base64 char set in that '+' and '/' are
    * replaced with '-' and '_'.
    */
   private static final String DICT = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
   private static final int REVERSE_DICT_SIZE = 128;
-  private static final BitString[] REVERSE_DICT = new BitString[REVERSE_DICT_SIZE];
+  private static final int[] REVERSE_DICT = new int[REVERSE_DICT_SIZE];
   static {
+    Arrays.fill(REVERSE_DICT, NO_SYMBOL);
     for (int i = 0; i < DICT.length(); i++) {
-      BitStringBuilder builder = new BitStringBuilder();
-      FixedIntegerEncoder.encode(builder, i, 6);
-      REVERSE_DICT[DICT.charAt(i)] = builder.build();
+      // NOTE: the bit string is stored in a long[] and read from LSB to MSB
+      // but each base64 digit is read from MSB to LSB
+      // so they need to be reversed.
+      int value  = Integer.reverse(i) >>> -BASE64_BITS;
+      REVERSE_DICT[DICT.charAt(i)] = value;
     }
   }
 
@@ -35,9 +41,10 @@ public StringBuilder encode(BitStringBuilder bitStringBuilder) {
     int index = 0;
     while (index <= length - BASE64_BITS) {
       try {
-        int n = FixedIntegerEncoder.decode(bitString, index, BASE64_BITS);
+        int nextIndex = index + BASE64_BITS;
+        int n = FixedIntegerEncoder.decode(bitString, index, nextIndex);
         str.append(DICT.charAt(n));
-        index += BASE64_BITS;
+        index = nextIndex;
       } catch (DecodingException e) {
         throw new EncodingException("Unencodable Base64Url '" + bitString + "'");
       }
@@ -47,20 +54,51 @@ public StringBuilder encode(BitStringBuilder bitStringBuilder) {
   }
 
   public BitString decode(CharSequence str) {
-    int length = str.length();
-    BitStringBuilder sb = new BitStringBuilder(length * BASE64_BITS);
-    for (int i = 0; i < length; i++) {
-      char c = str.charAt(i);
-      BitString n = null;
-      if (c < REVERSE_DICT_SIZE) {
-        n = REVERSE_DICT[c];
+    try {
+      int length = str.length();
+      int bitLength = length * BASE64_BITS;
+      int numBlocks = length >> 2;
+      byte[] words = new byte[(numBlocks + 1) * 3];
+      int limit = numBlocks << 2;
+      int dst = 0;
+      int src = 0;
+      while (src < limit) {
+        int b1 = REVERSE_DICT[str.charAt(src++)];
+        int b2 = REVERSE_DICT[str.charAt(src++)];
+        int b3 = REVERSE_DICT[str.charAt(src++)];
+        int b4 = REVERSE_DICT[str.charAt(src++)];
+        if ((b1 | b2 | b3 | b4) < 0) {
+          throw new DecodingException("Undecodable Base64URL string");
+        }
+        int bits0 = b4 << 18 | b3 << 12 | b2 << 6 | b1;
+        words[dst++] = (byte)(bits0);
+        words[dst++] = (byte)(bits0 >>  8);
+        words[dst++] = (byte)(bits0 >> 16);
       }
-      if (n == null) {
-        throw new DecodingException("Undecodable Base64URL string");
+      if (length > limit) {
+        remainder(str, words, length, src, dst);
       }
-      sb.append(n);
+      return new BitString(new BitSet(words), bitLength);
+    } catch (ArrayIndexOutOfBoundsException e) {
+      throw new DecodingException("Undecodable Base64URL string");
+    }
+  }
 
+  private static final void remainder(CharSequence str, byte[] words, int length, int src, int dst) {
+    int b1 = src < length ? REVERSE_DICT[str.charAt(src)] : 0;
+    src++;
+    int b2 = src < length ? REVERSE_DICT[str.charAt(src)] : 0;
+    src++;
+    int b3 = src < length ? REVERSE_DICT[str.charAt(src)] : 0;
+    src++;
+    int b4 = src < length ? REVERSE_DICT[str.charAt(src)] : 0;
+    src++;
+    if ((b1 | b2 | b3 | b4) < 0) {
+      throw new DecodingException("Undecodable Base64URL string");
     }
-    return sb.build();
+    int bits0 = b4 << 18 | b3 << 12 | b2 << 6 | b1;
+    words[dst++] = (byte)(bits0);
+    words[dst++] = (byte)(bits0 >>  8);
+    words[dst++] = (byte)(bits0 >> 16);
   }
 }

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/bitstring/BitSet.java

@@ -0,0 +1,107 @@
+package com.iab.gpp.encoder.bitstring;
+
+import java.util.Arrays;
+import java.util.Base64;
+import com.iab.gpp.encoder.base64.TraditionalBase64UrlEncoder;
+import com.iab.gpp.encoder.datatype.encoder.IntegerSet;
+import com.iab.gpp.encoder.error.DecodingException;
+
+// a thin version of java.util.BitSet
+public final class BitSet {
+
+  private static final int ADDRESS_BITS_PER_WORD = 3;
+  public static final int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD;
+
+  /* Used to shift left or right for a partial word mask */
+  private static final int WORD_MASK = 0xffffffff;
+
+  private byte[] words;
+
+  public BitSet(byte[] words) {
+    this.words = words;
+  }
+
+  public BitSet(int initialCapacity) {
+    this(new byte[wordIndex(initialCapacity) + 1]);
+  }
+
+  public BitSet() {
+    this(new byte[0]);
+  }
+
+  public static int wordIndex(int index) {
+    if (index < 0) {
+      throw new DecodingException("got negative word index");
+    }
+    return index >> ADDRESS_BITS_PER_WORD;
+  }
+
+  private byte[] ensureIndex(int wordIndex) {
+    byte[] words = this.words;
+    int wordsUsed = words.length;
+    if (wordIndex >= wordsUsed) {
+      int request = Math.max(2 * wordsUsed, wordIndex + 1);
+      words = Arrays.copyOf(words, request);
+      this.words = words;
+    }
+    return words;
+  }
+
+  public boolean get(int bitIndex) {
+    int wordIndex = wordIndex(bitIndex);
+    byte[] words = this.words;
+    int bit = bitIndex % BITS_PER_WORD;
+    return (wordIndex < words.length)
+        && ((words[wordIndex] >>> bit) & 1) == 1;
+  }
+
+  public void clear(int from, int to) {
+    for (int i = from; i < to; i++) {
+      clear(i);
+    }
+  }
+
+  public void clear(int bitIndex) {
+    int wordIndex = wordIndex(bitIndex);
+    byte[] words = this.words;
+    if (wordIndex < words.length) {
+      int bit = bitIndex % BITS_PER_WORD;
+      words[wordIndex] &= ~(1 << bit);
+    }
+  }
+
+  public int nextSetBit(int fromIndex) {
+    byte[] words = this.words;
+    int wordsInUse = words.length;
+    int u = wordIndex(fromIndex);
+    if (u >= wordsInUse) {
+        return -1;
+    }
+
+    int bit = fromIndex % BITS_PER_WORD;
+    int word = words[u] & (WORD_MASK << bit);
+
+    while (true) {
+        if (word != 0) {
+            return (u * BITS_PER_WORD) + Integer.numberOfTrailingZeros(word);
+        }
+        if (++u == wordsInUse) {
+            return -1;
+        }
+        word = words[u];
+    }
+  }
+
+  public void set(int from, int to) {
+    for (int i = from; i < to; i++) {
+      set(i);
+    }
+  }
+
+  public void set(int bitIndex) {
+    int wordIndex = wordIndex(bitIndex);
+    byte[] words = ensureIndex(wordIndex);
+    int bit = bitIndex % BITS_PER_WORD;
+    words[wordIndex] |= (1 << bit);
+  }
+}

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/bitstring/BitString.java

@@ -1,7 +1,5 @@
 package com.iab.gpp.encoder.bitstring;
 
-import java.util.BitSet;
-import com.iab.gpp.encoder.datatype.encoder.IntegerBitSet;
 import com.iab.gpp.encoder.datatype.encoder.IntegerSet;
 import com.iab.gpp.encoder.error.DecodingException;
 
@@ -10,23 +8,13 @@ public final class BitString {
   public static final char FALSE = '0';
   public static final String TRUE_STRING = new String(new char[] {TRUE});
   public static final String FALSE_STRING = new String(new char[] {FALSE});
-  private static final BitString EMPTY = new BitString(new BitSet(), 0, 0);
 
   private final BitSet bitSet;
-  private final int from;
-  private final int to;
+  private final int length;
 
-  BitString(BitSet bitSet, int from, int to) {
+  public BitString(BitSet bitSet, int length) {
     this.bitSet = bitSet;
-    this.from = from;
-    this.to = to;
-  }
-
-  public static final BitString empty(int size) {
-    if (size == 0) {
-      return EMPTY;
-    }
-    return new BitString(new BitSet(size), 0, size);
+    this.length = length;
   }
 
   public static final BitString of(String str) {
@@ -45,54 +33,28 @@ public static final BitString of(String str) {
     return builder.build();
   }
 
-  public IntegerSet toIntegerSet() {
-    return new IntegerBitSet(bitSet, from, to, 1);
+  public IntegerSet toIntegerSet(int from, int to) {
+    return new IntegerSet(bitSet, from, to, 1);
   }
 
   @Override
   public String toString() {
     StringBuilder sb = new StringBuilder(length());
-    for (int i = from; i < to; i++) {
+    for (int i = 0; i < length; i++) {
       sb.append(bitSet.get(i) ? TRUE : FALSE);
     }
     return sb.toString();
   }
 
   public boolean getValue(int i) {
-    return bitSet.get(from + i);
-  }
-
-  public int length() {
-    return to - from;
-  }
-
-  public BitString substring(int i) {
-    return substring(i, length());
-  }
-
-  public BitString substring(int newFrom, int newTo) {
-    int length = length();
-    if (newFrom > newTo || newFrom < 0 || newFrom > length || newTo > length) {
-      throw new IllegalArgumentException("Invalid substring");
+    if (i >= length) {
+      throw new DecodingException("Bit string access out of range");
     }
-    int oldFrom = this.from;
-    return new BitString(bitSet, oldFrom + newFrom, oldFrom + newTo);
+    return bitSet.get(i);
   }
 
-  public BitString expandTo(int target) {
-    int needed = target - length();
-    if (needed == 0) {
-      return this;
-    }
-    if (needed < 0) {
-      return substring(0, target);
-    }
-    BitStringBuilder sb = new BitStringBuilder(target);
-    sb.append(this);
-    for (int i = 0; i < needed; i++) {
-      sb.append(false);
-    }
-    return sb.build();
+  public int length() {
+    return length;
   }
 
 }

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/bitstring/BitStringBuilder.java

@@ -1,6 +1,5 @@
 package com.iab.gpp.encoder.bitstring;
 
-import java.util.BitSet;
 
 public final class BitStringBuilder {
   private final BitSet bitSet;
@@ -15,7 +14,12 @@ public BitStringBuilder() {
   }
 
   public BitString build() {
-    return new BitString(bitSet, 0, length);
+    return new BitString(bitSet, length);
+  }
+
+  public BitStringBuilder extend(int length) {
+    this.length += length;
+    return this;
   }
 
   public BitStringBuilder append(boolean value) {
@@ -26,9 +30,8 @@ public BitStringBuilder append(boolean value) {
     return this;
   }
 
-  public BitStringBuilder append(BitString other) {
-    int otherLength = other.length();
-    for (int i = 0; i < otherLength; i++) {
+  public BitStringBuilder append(BitString other, int from, int to) {
+    for (int i = from; i < to; i++) {
       append(other.getValue(i));
     }
     return this;