4.x perf optimizations

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

@@ -1,7 +1,6 @@
 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;
 
@@ -46,7 +45,7 @@ public static final BitString of(String str) {
   }
 
   public IntegerSet toIntegerSet() {
-    return new IntegerBitSet(bitSet, from, to, 1);
+    return new IntegerSet(bitSet, from, to, 1);
   }
 
   @Override

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/AbstractDirtyableBitStringDataType.java

@@ -0,0 +1,24 @@
+package com.iab.gpp.encoder.datatype;
+
+import com.iab.gpp.encoder.datatype.encoder.Dirtyable;
+
+// This class is used to handle collection types.
+// It is important that we monitor the collections we return for changes.
+public abstract class AbstractDirtyableBitStringDataType<T extends Dirtyable>
+    extends AbstractEncodableBitStringDataType<T> {
+
+  protected AbstractDirtyableBitStringDataType(boolean hardFailIfMissing) {
+    super(hardFailIfMissing);
+  }
+
+  @Override
+  public boolean isDirty() {
+    return super.isDirty() || value.isDirty();
+  }
+
+  @Override
+  public void setDirty(boolean dirty) {
+    super.setDirty(dirty);
+    value.setDirty(dirty);
+  }
+}

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/AbstractEncodableBitStringDataType.java

@@ -23,11 +23,11 @@ public AbstractEncodableBitStringDataType<T> withValidator(Predicate<T> validato
     return this;
   }
 
-  public boolean hasValue() {
+  public final boolean hasValue() {
     return this.value != null;
   }
 
-  public T getValue() {
+  public final T getValue() {
     return this.value;
   }
 
@@ -48,7 +48,7 @@ public void setValue(Object value) {
 
   }
 
-  public boolean getHardFailIfMissing() {
+  public final boolean getHardFailIfMissing() {
     return this.hardFailIfMissing;
   }
 

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/DataType.java

@@ -1,9 +1,9 @@
 package com.iab.gpp.encoder.datatype;
 
-public interface DataType<T> {
+import com.iab.gpp.encoder.datatype.encoder.Dirtyable;
+
+public interface DataType<T> extends Dirtyable {
   boolean hasValue();
   T getValue();
   void setValue(Object value);
-  boolean isDirty();
-  void setDirty(boolean dirty);
 }

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/DirtyableList.java

@@ -0,0 +1,103 @@
+package com.iab.gpp.encoder.datatype;
+
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collection;
+import com.iab.gpp.encoder.datatype.encoder.Dirtyable;
+
+// This class tracks whether a list has been modified.
+final class DirtyableList<T extends Dirtyable> extends AbstractList<T> implements Dirtyable {
+
+  private boolean dirty;
+  private final ArrayList<T> delegate;
+
+  DirtyableList() {
+    this.delegate = new ArrayList<>();
+  }
+
+  @Override
+  public int size() {
+    return delegate.size();
+  }
+
+  @Override
+  public boolean add(T value) {
+    boolean result = delegate.add(value);
+    dirty = true;
+    return result;
+  }
+
+  @Override
+  public T get(int index) {
+    return delegate.get(index);
+  }
+
+  @Override
+  public T set(int index, T value) {
+    T prior = delegate.set(index, value);
+    dirty = true;
+    return prior;
+  }
+
+  @Override
+  public void add(int index, T element) {
+    delegate.add(index, element);
+    dirty = true;
+  }
+
+  @Override
+  public T remove(int index) {
+    T old = delegate.remove(index);
+    dirty = true;
+    return old;
+  }
+
+  @Override
+  public int indexOf(Object o) {
+    return delegate.indexOf(o);
+  }
+
+  @Override
+  public int lastIndexOf(Object o) {
+    return delegate.lastIndexOf(o);
+  }
+
+  @Override
+  public void clear() {
+    delegate.clear();
+    dirty = true;
+  }
+
+  @Override
+  public boolean addAll(Collection<? extends T> c) {
+    boolean result = delegate.addAll(c);
+    dirty = true;
+    return result;
+  }
+
+  @Override
+  public String toString() {
+    return delegate.toString();
+  }
+
+  @Override
+  public boolean isDirty() {
+    int size = delegate.size();
+    for (int i = 0; i < size; i++) {
+      T value = delegate.get(i);
+      if (value.isDirty()) {
+        return true;
+      }
+    }
+    return dirty;
+  }
+
+  @Override
+  public void setDirty(boolean dirty) {
+    int size = delegate.size();
+    for (int i = 0; i < size; i++) {
+      delegate.get(i).setDirty(dirty);
+    }
+    this.dirty = dirty;
+  }
+}

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/EncodableArrayOfFixedIntegerRanges.java

@@ -1,7 +1,5 @@
 package com.iab.gpp.encoder.datatype;
 
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 import com.iab.gpp.encoder.bitstring.BitString;
@@ -12,7 +10,7 @@
 import com.iab.gpp.encoder.error.DecodingException;
 import com.iab.gpp.encoder.error.EncodingException;
 
-public final class EncodableArrayOfFixedIntegerRanges extends AbstractEncodableBitStringDataType<List<RangeEntry>> {
+public final class EncodableArrayOfFixedIntegerRanges extends AbstractDirtyableBitStringDataType<DirtyableList<RangeEntry>> {
 
   private int keyBitStringLength;
   private int typeBitStringLength;
@@ -21,7 +19,7 @@ public EncodableArrayOfFixedIntegerRanges(int keyBitStringLength, int typeBitStr
     super(hardFailIfMissing);
     this.keyBitStringLength = keyBitStringLength;
     this.typeBitStringLength = typeBitStringLength;
-    this.value = Collections.emptyList();
+    this.value = new DirtyableList<>();
   }
 
   @Override
@@ -45,7 +43,7 @@ public void encode(BitStringBuilder sb) {
   public void decode(BitString bitString) {
     try {
       int size = FixedIntegerEncoder.decode(bitString, 0, 12);
-      List<RangeEntry> entries = new ArrayList<>(size);
+      value.clear();
       int index = 12;
       for (int i = 0; i < size; i++) {
         int key = FixedIntegerEncoder.decode(bitString, index, keyBitStringLength);
@@ -58,11 +56,9 @@ public void decode(BitString bitString) {
         IntegerSet ids = FixedIntegerRangeEncoder.decode(substring);
         index += substring.length();
 
-        entries.add(new RangeEntry(key, type, ids));
+        RangeEntry entry = new RangeEntry(key, type, ids);
+        value.add(entry);
       }
-
-      // NOTE: this requires that updates to structure be done using the setter
-      this.value = Collections.unmodifiableList(entries);
     } catch (Exception e) {
       throw new DecodingException(e);
     }
@@ -98,4 +94,10 @@ public BitString substring(BitString bitString, int fromIndex) throws SubstringE
     }
   }
 
+  @SuppressWarnings("unchecked")
+  @Override
+  public void setValue(Object value) {
+    this.value.clear();
+    this.value.addAll((List<RangeEntry>) value);
+  }
 }

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/EncodableFibonacciIntegerRange.java

@@ -3,19 +3,18 @@
 import java.util.Collection;
 import com.iab.gpp.encoder.bitstring.BitString;
 import com.iab.gpp.encoder.bitstring.BitStringBuilder;
-import com.iab.gpp.encoder.datatype.encoder.IntegerBitSet;
 import com.iab.gpp.encoder.datatype.encoder.FibonacciIntegerEncoder;
 import com.iab.gpp.encoder.datatype.encoder.FibonacciIntegerRangeEncoder;
 import com.iab.gpp.encoder.datatype.encoder.FixedIntegerEncoder;
 import com.iab.gpp.encoder.datatype.encoder.IntegerSet;
 import com.iab.gpp.encoder.error.DecodingException;
 import com.iab.gpp.encoder.error.EncodingException;
 
-public final class EncodableFibonacciIntegerRange extends AbstractEncodableBitStringDataType<IntegerSet> {
+public final class EncodableFibonacciIntegerRange extends AbstractDirtyableBitStringDataType<IntegerSet> {
 
   public EncodableFibonacciIntegerRange() {
     super(true);
-    this.value = new IntegerBitSet();
+    this.value = new IntegerSet();
   }
 
   public void encode(BitStringBuilder builder) {
@@ -57,9 +56,4 @@ public void setValue(Object value) {
     this.value.clear();
     this.value.addAll((Collection<Integer>) value);
   }
-
-  @Override
-  public IntegerSet getValue() {
-    return new ManagedIntegerSet(this, super.getValue());
-  }
 }

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/EncodableFixedBitfield.java

@@ -3,20 +3,19 @@
 import java.util.Collection;
 import com.iab.gpp.encoder.bitstring.BitString;
 import com.iab.gpp.encoder.bitstring.BitStringBuilder;
-import com.iab.gpp.encoder.datatype.encoder.IntegerBitSet;
 import com.iab.gpp.encoder.datatype.encoder.FixedBitfieldEncoder;
 import com.iab.gpp.encoder.datatype.encoder.IntegerSet;
 import com.iab.gpp.encoder.error.DecodingException;
 import com.iab.gpp.encoder.error.EncodingException;
 
-public final class EncodableFixedBitfield extends AbstractEncodableBitStringDataType<IntegerSet> {
+public final class EncodableFixedBitfield extends AbstractDirtyableBitStringDataType<IntegerSet> {
 
   private final int numElements;
 
   public EncodableFixedBitfield(int numElements) {
     super(true);
     this.numElements = numElements;
-    this.value = new IntegerBitSet(numElements);
+    this.value = new IntegerSet(numElements);
   }
 
   public void encode(BitStringBuilder builder) {
@@ -49,9 +48,4 @@ public void setValue(Object value) {
     this.value.clear();
     this.value.addAll((Collection<Integer>) value);
   }
-
-  @Override
-  public IntegerSet getValue() {
-    return new ManagedIntegerSet(this, super.getValue());
-  }
 }

iabgpp-encoder/src/main/java/com/iab/gpp/encoder/datatype/EncodableFixedIntegerList.java

@@ -1,6 +1,5 @@
 package com.iab.gpp.encoder.datatype;
 
-import java.util.ArrayList;
 import java.util.List;
 
 import com.iab.gpp.encoder.bitstring.BitString;
@@ -9,22 +8,16 @@
 import com.iab.gpp.encoder.error.DecodingException;
 import com.iab.gpp.encoder.error.EncodingException;
 
-public final class EncodableFixedIntegerList extends AbstractEncodableBitStringDataType<List<Integer>> {
+public final class EncodableFixedIntegerList extends AbstractDirtyableBitStringDataType<FixedIntegerList> {
 
   private int elementBitStringLength;
   private int numElements;
 
-  protected EncodableFixedIntegerList(int elementBitStringLength, int numElements) {
+  public EncodableFixedIntegerList(int elementBitStringLength, int numElements) {
     super(true);
     this.elementBitStringLength = elementBitStringLength;
     this.numElements = numElements;
-  }
-
-  public EncodableFixedIntegerList(int elementBitStringLength, List<Integer> value) {
-    super(true);
-    this.elementBitStringLength = elementBitStringLength;
-    this.numElements = value.size();
-    setValue(value);
+    super.setValue(new FixedIntegerList(numElements));
   }
 
   public void encode(BitStringBuilder builder) {
@@ -37,7 +30,7 @@ public void encode(BitStringBuilder builder) {
 
   public void decode(BitString bitString) {
     try {
-      this.value = FixedIntegerListEncoder.decode(bitString, this.elementBitStringLength, this.numElements);
+      FixedIntegerListEncoder.decode(this.value, bitString, this.elementBitStringLength, this.numElements);
     } catch (Exception e) {
       throw new DecodingException(e);
     }
@@ -54,18 +47,12 @@ public BitString substring(BitString bitString, int fromIndex) throws SubstringE
   @SuppressWarnings("unchecked")
   @Override
   public void setValue(Object value) {
-    List<Integer> v = new ArrayList<>((List<Integer>) value);
-    for (int i = v.size(); i < numElements; i++) {
-      v.add(0);
+    List<Integer> list = (List<Integer>) value;
+    int size = list.size();
+    for (int i = 0; i < numElements; i++) {
+      this.value.set(i, i < size ? list.get(i) : 0);
     }
-    if (v.size() > numElements) {
-      v = v.subList(0, numElements);
-    }
-    super.setValue(v);
-  }
-
-  @Override
-  public List<Integer> getValue() {
-    return new ManagedFixedList<>(this, super.getValue());
+    // call validator
+    super.setValue(this.value);
   }
 }