reorder Transaction.java to based on web sdk

Author: Brian Chen

firebase-firestore/src/main/java/com/google/firebase/firestore/core/Transaction.java

@@ -38,6 +38,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.Executor;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
@@ -64,29 +65,6 @@ public Transaction(Datastore d) {
     datastore = d;
   }
 
-  private void recordVersion(MaybeDocument doc) throws FirebaseFirestoreException {
-    SnapshotVersion docVersion;
-    if (doc instanceof Document) {
-      docVersion = doc.getVersion();
-    } else if (doc instanceof NoDocument) {
-      // For nonexistent docs, we must use precondition with version 0 when we overwrite them.
-      docVersion = SnapshotVersion.NONE;
-    } else {
-      throw fail("Unexpected document type in transaction: " + doc.getClass().getCanonicalName());
-    }
-
-    if (readVersions.containsKey(doc.getKey())) {
-      SnapshotVersion existingVersion = readVersions.get(doc.getKey());
-      if (!existingVersion.equals(doc.getVersion())) {
-        // This transaction will fail no matter what.
-        throw new FirebaseFirestoreException(
-            "Document version changed between two reads.", Code.ABORTED);
-      }
-    } else {
-      readVersions.put(doc.getKey(), docVersion);
-    }
-  }
-
   /**
    * Takes a set of keys and asynchronously attempts to fetch all the documents from the backend,
    * ignoring any local changes.
@@ -114,51 +92,6 @@ public Task<List<MaybeDocument>> lookup(List<DocumentKey> keys) {
             });
   }
 
-  private void write(List<Mutation> mutations) {
-    ensureCommitNotCalled();
-    this.mutations.addAll(mutations);
-  }
-
-  /**
-   * Returns version of this doc when it was read in this transaction as a precondition, or no
-   * precondition if it was not read.
-   */
-  private Precondition precondition(DocumentKey key) {
-    @Nullable SnapshotVersion version = readVersions.get(key);
-    if (version != null) {
-      return Precondition.updateTime(version);
-    } else {
-      return Precondition.NONE;
-    }
-  }
-
-  /**
-   * Returns the precondition for a document if the operation is an update, based on the provided
-   * UpdateOptions.
-   */
-  private Precondition preconditionForUpdate(DocumentKey key) throws FirebaseFirestoreException {
-    @Nullable SnapshotVersion version = this.readVersions.get(key);
-    if (version != null && version.equals(SnapshotVersion.NONE)) {
-      // The document to update doesn't exist, so fail the transaction.
-      //
-      // This has to be validated locally because you can't send a precondition that a document
-      // does not exist without changing the semantics of the backend write to be an insert. This is
-      // the reverse of what we want, since we want to assert that the document doesn't exist but
-      // then send the update and have it fail. Since we can't express that to the backend, we have
-      // to validate locally.
-      //
-      // Note: this can change once we can send separate verify writes in the transaction.
-      throw new FirebaseFirestoreException(
-          "Can't update a document that doesn't exist.", Code.INVALID_ARGUMENT);
-    } else if (version != null) {
-      // Document exists, just base precondition on document update time.
-      return Precondition.updateTime(version);
-    } else {
-      // Document was not read, so we just use the preconditions for a blind write.
-      return Precondition.exists(true);
-    }
-  }
-
   /** Stores a set mutation for the given key and value, to be committed when commit() is called. */
   public void set(DocumentKey key, ParsedSetData data) {
     write(data.toMutationList(key, precondition(key)));
@@ -230,6 +163,74 @@ private static Executor createDefaultExecutor() {
     return executor;
   }
 
+  private void recordVersion(MaybeDocument doc) throws FirebaseFirestoreException {
+    SnapshotVersion docVersion;
+    if (doc instanceof Document) {
+      docVersion = doc.getVersion();
+    } else if (doc instanceof NoDocument) {
+      // For nonexistent docs, we must use precondition with version 0 when we overwrite them.
+      docVersion = SnapshotVersion.NONE;
+    } else {
+      throw fail("Unexpected document type in transaction: " + doc.getClass().getCanonicalName());
+    }
+
+    if (readVersions.containsKey(doc.getKey())) {
+      SnapshotVersion existingVersion = readVersions.get(doc.getKey());
+      if (!existingVersion.equals(doc.getVersion())) {
+        // This transaction will fail no matter what.
+        throw new FirebaseFirestoreException(
+                "Document version changed between two reads.", Code.ABORTED);
+      }
+    } else {
+      readVersions.put(doc.getKey(), docVersion);
+    }
+  }
+
+  /**
+   * Returns version of this doc when it was read in this transaction as a precondition, or no
+   * precondition if it was not read.
+   */
+  private Precondition precondition(DocumentKey key) {
+    @Nullable SnapshotVersion version = readVersions.get(key);
+    if (version != null) {
+      return Precondition.updateTime(version);
+    } else {
+      return Precondition.NONE;
+    }
+  }
+
+  /**
+   * Returns the precondition for a document if the operation is an update, based on the provided
+   * UpdateOptions.
+   */
+  private Precondition preconditionForUpdate(DocumentKey key) throws FirebaseFirestoreException {
+    @Nullable SnapshotVersion version = this.readVersions.get(key);
+    if (version != null && version.equals(SnapshotVersion.NONE)) {
+      // The document to update doesn't exist, so fail the transaction.
+      //
+      // This has to be validated locally because you can't send a precondition that a document
+      // does not exist without changing the semantics of the backend write to be an insert. This is
+      // the reverse of what we want, since we want to assert that the document doesn't exist but
+      // then send the update and have it fail. Since we can't express that to the backend, we have
+      // to validate locally.
+      //
+      // Note: this can change once we can send separate verify writes in the transaction.
+      throw new FirebaseFirestoreException(
+              "Can't update a document that doesn't exist.", Code.INVALID_ARGUMENT);
+    } else if (version != null) {
+      // Document exists, just base precondition on document update time.
+      return Precondition.updateTime(version);
+    } else {
+      // Document was not read, so we just use the preconditions for a blind write.
+      return Precondition.exists(true);
+    }
+  }
+
+  private void write(List<Mutation> mutations) {
+    ensureCommitNotCalled();
+    this.mutations.addAll(mutations);
+  }
+
   private void ensureCommitNotCalled() {
     hardAssert(
         !committed,