Static helper

Author: schmidt-sebastian

firebase-firestore/src/main/java/com/google/firebase/firestore/local/SQLiteIndexManager.java

@@ -17,7 +17,7 @@
 import static com.google.firebase.firestore.model.Values.isArray;
 import static com.google.firebase.firestore.util.Assert.fail;
 import static com.google.firebase.firestore.util.Assert.hardAssert;
-import static com.google.firebase.firestore.util.Util.advanceIterator;
+import static com.google.firebase.firestore.util.Util.diffCollections;
 import static com.google.firebase.firestore.util.Util.repeatSequence;
 import static java.lang.Math.max;
 
@@ -53,8 +53,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.SortedSet;
-import java.util.TreeSet;
 
 /** A persisted implementation of IndexManager. */
 final class SQLiteIndexManager implements IndexManager {
@@ -258,42 +256,11 @@ private void updateEntries(
       Logger.debug(TAG, "Updating index entries for document '%s'", document.getKey());
     }
 
-    SortedSet<IndexEntry> existingIndexes = new TreeSet<>(existingEntries);
-    Iterator<IndexEntry> existingIt = existingIndexes.iterator();
-    @Nullable IndexEntry existingValue = advanceIterator(existingIt);
-
-    List<IndexEntry> updatedIndexes = new ArrayList<>(updatedEntries);
-    Iterator<IndexEntry> updatedIt = updatedIndexes.iterator();
-    @Nullable IndexEntry updatedValue = advanceIterator(updatedIt);
-
-    while (existingValue != null || updatedValue != null) {
-      boolean deleted = false;
-      boolean updated = false;
-
-      if (existingValue != null && updatedValue != null) {
-        int cmp = existingValue.compareTo(updatedValue);
-        if (cmp < 0) {
-          deleted = true;
-        } else if (cmp > 0) {
-          updated = true;
-        }
-      } else if (existingValue != null) {
-        deleted = true;
-      } else {
-        updated = true;
-      }
-
-      if (deleted) {
-        deleteIndexEntry(document, existingValue);
-        existingValue = advanceIterator(existingIt);
-      } else if (updated) {
-        addIndexEntry(document, updatedValue);
-        updatedValue = advanceIterator(updatedIt);
-      } else {
-        existingValue = advanceIterator(existingIt);
-        updatedValue = advanceIterator(updatedIt);
-      }
-    }
+    diffCollections(
+        existingEntries,
+        updatedEntries,
+        entry -> addIndexEntry(document, entry),
+        entry -> deleteIndexEntry(document, entry));
   }
 
   @Override

firebase-firestore/src/main/java/com/google/firebase/firestore/util/Util.java

@@ -28,6 +28,7 @@
 import io.grpc.StatusRuntimeException;
 import java.security.SecureRandom;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
@@ -164,8 +165,8 @@ public static Continuation<Void, Void> voidErrorTransformer() {
    * Converts varargs from an update call to a list of objects, ensuring that the arguments
    * alternate between String/FieldPath and Objects.
    *
-   * @param fieldPathOffset The offset of the first field path in the original update API (used as
-   *     the index in error messages)
+   * @param fieldPathOffset The offset of the first field path in the before update API (used as the
+   *     index in error messages)
    */
   public static List<Object> collectUpdateArguments(
       int fieldPathOffset, Object field, Object val, Object... fieldsAndValues) {
@@ -277,9 +278,89 @@ public static StringBuilder repeatSequence(
     return sb;
   }
 
+  /**
+   * Compares two collections for equality using the provided comparator. The method computes the
+   * intersection and invokes `onAdd` for every element that is in `after` but not `before`.
+   * `onDelete` is invoked for every element in `before` but missing from `after`.
+   *
+   * <p>The method creates a copy of both `before` and `after` and runs in O(n log n), where n is
+   * the size of the two lists.
+   *
+   * @param before The elements that exist in the original set.
+   * @param after The elements to diff against the original set.
+   * @param comparator The comparator to use to define equality between elements.
+   * @param onAdd A function to invoke for every element that is part of `after` but not `before`.
+   * @param onDelete A function to invoke for every element that is part of `before` but not
+   *     `after`.
+   */
+  public static <T> void diffCollections(
+      Collection<T> before,
+      Collection<T> after,
+      Comparator<T> comparator,
+      Consumer<T> onAdd,
+      Consumer<T> onDelete) {
+    List<T> beforeEntries = new ArrayList<>(before);
+    Collections.sort(beforeEntries, comparator);
+    Iterator<T> beforeIt = beforeEntries.iterator();
+    @Nullable T beforeValue = advanceIterator(beforeIt);
+
+    List<T> afterEntries = new ArrayList<>(after);
+    Collections.sort(afterEntries, comparator);
+    Iterator<T> afterIt = afterEntries.iterator();
+    @Nullable T afterValue = advanceIterator(afterIt);
+
+    while (beforeValue != null || afterValue != null) {
+      boolean deleted = false;
+      boolean added = false;
+
+      if (beforeValue != null && afterValue != null) {
+        int cmp = comparator.compare(beforeValue, afterValue);
+        if (cmp < 0) {
+          deleted = true;
+        } else if (cmp > 0) {
+          added = true;
+        }
+      } else if (beforeValue != null) {
+        deleted = true;
+      } else {
+        added = true;
+      }
+
+      if (deleted) {
+        onDelete.accept(beforeValue);
+        beforeValue = advanceIterator(beforeIt);
+      } else if (added) {
+        onAdd.accept(afterValue);
+        afterValue = advanceIterator(afterIt);
+      } else {
+        beforeValue = advanceIterator(beforeIt);
+        afterValue = advanceIterator(afterIt);
+      }
+    }
+  }
+
+  /**
+   * Compares two collections for equality using their natural ordering. The method computes the
+   * intersection and invokes `onAdd` for every element that is in `after` but not `before`.
+   * `onDelete` is invoked for every element in `before` but missing from `after`.
+   *
+   * <p>The method creates a copy of both `before` and `after` and runs in O(n log n), where n is
+   * the size of the two lists.
+   *
+   * @param before The elements that exist in the original set.
+   * @param after The elements to diff against the original set.
+   * @param onAdd A function to invoke for every element that is part of `after` but not `before`.
+   * @param onDelete A function to invoke for every element that is part of `before` but not
+   *     `after`.
+   */
+  public static <T extends Comparable<T>> void diffCollections(
+      Collection<T> before, Collection<T> after, Consumer<T> onAdd, Consumer<T> onDelete) {
+    diffCollections(before, after, Comparable::compareTo, onAdd, onDelete);
+  }
+
   /** Returns the next element from the iterator or `null` if none available. */
   @Nullable
-  public static <T> T advanceIterator(Iterator<T> it) {
+  private static <T> T advanceIterator(Iterator<T> it) {
     return it.hasNext() ? it.next() : null;
   }
 }