GenericOptions

Author: tom-andersen

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/PipelineTest.java

@@ -48,6 +48,7 @@
 import com.google.firebase.firestore.pipeline.Constant;
 import com.google.firebase.firestore.pipeline.Field;
 import com.google.firebase.firestore.pipeline.Function;
+import com.google.firebase.firestore.pipeline.GenericStage;
 import com.google.firebase.firestore.testutil.IntegrationTestUtil;
 import java.util.Collections;
 import java.util.LinkedHashMap;
@@ -284,7 +285,7 @@ public void groupAndAccumulateResultsGeneric() {
                 "aggregate",
                 ImmutableMap.of("avgRating", AggregateExpr.avg("rating")),
                 ImmutableMap.of("genre", Field.of("genre")))
-            .genericStage("where", gt("avgRating", 4.3))
+            .genericStage(GenericStage.of("where").withArguments(gt("avgRating", 4.3)))
             .genericStage("sort", Field.of("avgRating").descending())
             .execute();
     assertThat(waitFor(execute).getResults())

firebase-firestore/src/main/java/com/google/firebase/firestore/Pipeline.kt

@@ -99,8 +99,10 @@ internal constructor(
       .addAllStages(stages.map { it.toProtoStage(userDataReader) })
       .build()
 
-  fun genericStage(name: String, vararg params: Any) =
-    append(GenericStage(name, params.map(GenericArg::from)))
+  fun genericStage(name: String, vararg arguments: Any): Pipeline =
+    append(GenericStage(name, arguments.map(GenericArg::from)))
+
+  fun genericStage(stage: GenericStage): Pipeline = append(stage)
 
   fun addFields(vararg fields: Selectable): Pipeline = append(AddFieldsStage(fields))
 

firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/stage.kt

@@ -22,7 +22,7 @@ import com.google.firestore.v1.Pipeline
 import com.google.firestore.v1.Value
 
 abstract class Stage
-private constructor(private val name: String, private val options: InternalOptions) {
+private constructor(protected val name: String, private val options: InternalOptions) {
   internal constructor(name: String) : this(name, InternalOptions.EMPTY)
   internal constructor(name: String, options: AbstractOptions<*>) : this(name, options.options)
   internal fun toProtoStage(userDataReader: UserDataReader): Pipeline.Stage {
@@ -35,10 +35,20 @@ private constructor(private val name: String, private val options: InternalOptio
   internal abstract fun args(userDataReader: UserDataReader): Sequence<Value>
 }
 
-internal class GenericStage
-internal constructor(name: String, private val params: List<GenericArg>) : Stage(name) {
+class GenericStage
+private constructor(name: String, private val arguments: List<GenericArg>, private val options: GenericOptions) : Stage(name, options) {
+  internal constructor(name: String, arguments: List<GenericArg>) : this(name, arguments, GenericOptions.DEFAULT)
+  companion object {
+    @JvmStatic
+    fun of(name: String) = GenericStage(name, emptyList())
+  }
+
+  fun withArguments(vararg arguments: Any): GenericStage = GenericStage(name, arguments.map(GenericArg::from), options)
+
+  fun withOptions(options: GenericOptions): GenericStage = GenericStage(name, arguments, options)
+
   override fun args(userDataReader: UserDataReader): Sequence<Value> =
-    params.asSequence().map { it.toProto(userDataReader) }
+    arguments.asSequence().map { it.toProto(userDataReader) }
 }
 
 internal sealed class GenericArg {
@@ -77,6 +87,14 @@ internal sealed class GenericArg {
   }
 }
 
+class GenericOptions private constructor(options: InternalOptions) : AbstractOptions<GenericOptions>(options) {
+  companion object {
+    @JvmField
+    val DEFAULT = GenericOptions(InternalOptions.EMPTY)
+  }
+  override fun self(options: InternalOptions) = GenericOptions(options)
+}
+
 internal class DatabaseSource : Stage("database") {
   override fun args(userDataReader: UserDataReader): Sequence<Value> = emptySequence()
 }