Cleanup

Author: schmidt-sebastian

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

@@ -31,7 +31,6 @@
 import com.google.firebase.firestore.model.mutation.MutationBatch;
 import com.google.firebase.firestore.model.mutation.Overlay;
 import com.google.firebase.firestore.model.mutation.PatchMutation;
-import com.google.firebase.firestore.util.Function;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -112,36 +111,31 @@ Document getDocument(DocumentKey key) {
    */
   ImmutableSortedMap<DocumentKey, Document> getDocuments(Iterable<DocumentKey> keys) {
     Map<DocumentKey, MutableDocument> docs = remoteDocumentCache.getAll(keys);
-    return getLocalViewOfDocuments(docs, documentOverlayCache::getOverlay, new HashSet<>());
+    return getLocalViewOfDocuments(docs, new HashSet<>());
   }
 
-  /**
-   * Similar to {@link #getDocuments}, but creates the local view from the given {@code baseDocs}
-   * without retrieving documents from the local store.
-   *
-   * @param docs The documents to apply local mutations to get the local views.
-   * @param existenceStateChanged The set of document keys whose existence state is changed. This is
-   *     useful to determine if some documents overlay needs to be recalculated.
-   */
   private ImmutableSortedMap<DocumentKey, Document> getLocalViewOfDocuments(
       Map<DocumentKey, MutableDocument> docs,
-      Function<DocumentKey, Overlay> overlays,
+      Map<DocumentKey, Overlay> cachedOverlays,
       Set<DocumentKey> existenceStateChanged) {
     ImmutableSortedMap<DocumentKey, Document> results = emptyDocumentMap();
     Map<DocumentKey, MutableDocument> recalculateDocuments = new HashMap<>();
-    for (Map.Entry<DocumentKey, MutableDocument> entry : docs.entrySet()) {
-      Overlay overlay = overlays.apply(entry.getKey());
+    for (MutableDocument doc : docs.values()) {
+      Overlay overlay =
+          cachedOverlays.containsKey(doc.getKey())
+              ? cachedOverlays.get(doc.getKey())
+              : documentOverlayCache.getOverlay(entry.getKey());
       // Recalculate an overlay if the document's existence state is changed due to a remote
       // event *and* the overlay is a PatchMutation. This is because document existence state
       // can change if some patch mutation's preconditions are met.
       // NOTE: we recalculate when `overlay` is null as well, because there might be a patch
       // mutation whose precondition does not match before the change (hence overlay==null),
       // but would now match.
-      if (existenceStateChanged.contains(entry.getKey())
+      if (existenceStateChanged.contains(doc.getKey())
           && (overlay == null || overlay.getMutation() instanceof PatchMutation)) {
-        recalculateDocuments.put(entry.getKey(), docs.get(entry.getKey()));
+        recalculateDocuments.put(doc.getKey(), doc);
       } else if (overlay != null) {
-        overlay.getMutation().applyToLocalView(entry.getValue(), null, Timestamp.now());
+        overlay.getMutation().applyToLocalView(doc, null, Timestamp.now());
       }
     }
 
@@ -162,9 +156,8 @@ private ImmutableSortedMap<DocumentKey, Document> getLocalViewOfDocuments(
    *     useful to determine if some documents overlay needs to be recalculated.
    */
   ImmutableSortedMap<DocumentKey, Document> getLocalViewOfDocuments(
-          Map<DocumentKey, MutableDocument> docs,
-          Set<DocumentKey> existenceStateChanged) {
-    return getLocalViewOfDocuments(docs, documentOverlayCache::getOverlay, existenceStateChanged);
+      Map<DocumentKey, MutableDocument> docs, Set<DocumentKey> existenceStateChanged) {
+    return getLocalViewOfDocuments(docs, Collections.emptyMap(), existenceStateChanged);
   }
 
   private void recalculateAndSaveOverlays(Map<DocumentKey, MutableDocument> docs) {
@@ -282,33 +275,28 @@ private ImmutableSortedMap<DocumentKey, Document> getDocumentsMatchingCollection
    *     processed batch id.
    */
   LocalDocumentsResult getNextDocuments(String collectionGroup, IndexOffset offset, int count) {
+    int largestBatchId = -1;
     Map<DocumentKey, MutableDocument> docs =
         remoteDocumentCache.getAll(collectionGroup, offset, count);
-    final Map<DocumentKey, Overlay> overlays = new HashMap<>();
+    Map<DocumentKey, Overlay> overlays =
+        count - docs.size() > 0
+            ? documentOverlayCache.getOverlays(
+                collectionGroup, offset.getLargestBatchId(), count - docs.size())
+            : Collections.emptyMap();
 
-    int largestBatchId = -1;
-    if (count - docs.size() > 0) {
-      overlays.putAll(
-          documentOverlayCache.getOverlays(
-              collectionGroup, offset.getLargestBatchId(), count - docs.size()));
+    if (!overlays.isEmpty()) {
       List<DocumentKey> mutatedKeys = new ArrayList<>();
-      for (Map.Entry<DocumentKey, Overlay> entry : overlays.entrySet()) {
-        if (!docs.containsKey(entry.getKey())) {
-          mutatedKeys.add(entry.getKey());
+      for (Overlay overlay : overlays.values()) {
+        if (!docs.containsKey(overlay.getKey())) {
+          mutatedKeys.add(overlay.getKey());
         }
-        largestBatchId = Math.max(largestBatchId, entry.getValue().getLargestBatchId());
+        largestBatchId = Math.max(largestBatchId, overlay.getLargestBatchId());
       }
       docs.putAll(remoteDocumentCache.getAll(mutatedKeys));
     }
 
     ImmutableSortedMap<DocumentKey, Document> localDocs =
-        getLocalViewOfDocuments(
-            docs,
-            key ->
-                overlays.containsKey(key)
-                    ? overlays.get(key)
-                    : documentOverlayCache.getOverlay(key),
-            Collections.emptySet());
+        getLocalViewOfDocuments(docs, overlays, Collections.emptySet());
     return new LocalDocumentsResult(largestBatchId, localDocs);
   }