com.hazelcast.jet.pipeline

## Class AggregateBuilder<R0>

- java.lang.Object
- - com.hazelcast.jet.pipeline.AggregateBuilder<R0>

- Type Parameters:
    `R0` - type of the aggregation result for stream-0

      public class AggregateBuilder<R0>
      extends Object

  Offers a step-by-step API to build a pipeline stage that co-aggregates the data from several input stages. To obtain it, call `BatchStage.aggregateBuilder()` on the first stage you are co-aggregating and refer to that method's Javadoc for further details.

  Note: this is not a builder of `AggregateOperation`. If that' s what you are looking for, go `here`.

- - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `<T,R> Tag<R>` | `add(BatchStage<T> stage, AggregateOperation1<? super T,?,? extends R> aggrOp)` Adds another stage that will contribute its data to the aggregate operation to be performed.
    `BatchStage<ItemsByTag>` | `build()` Creates and returns a pipeline stage that performs the co-aggregation of the stages registered with this builder object.
    `<R> BatchStage<R>` | `build(DistributedFunction<? super ItemsByTag,? extends R> finishFn)` Creates and returns a pipeline stage that performs the co-aggregation of the stages registered with this builder object.
    `Tag<R0>` | `tag0()` Returns the tag corresponding to the pipeline stage this builder was obtained from.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### tag0

          @Nonnull
          public Tag<R0> tag0()

      Returns the tag corresponding to the pipeline stage this builder was obtained from. Use this tag to refer to this stage when building the `AggregateOperation` that you'll pass to `build(aggrOp)`.

    - #### add

          @Nonnull
          public <T,R> Tag<R> add(@Nonnull
                                           BatchStage<T> stage,
                                           @Nonnull
                                           AggregateOperation1<? super T,?,? extends R> aggrOp)

      Adds another stage that will contribute its data to the aggregate operation to be performed. Returns the tag you'll use to refer to this stage when building the `AggregateOperation` that you'll pass to `build()`.

    - #### build

          @Nonnull
          public <R> BatchStage<R> build(@Nonnull
                                                  DistributedFunction<? super ItemsByTag,? extends R> finishFn)

      Creates and returns a pipeline stage that performs the co-aggregation of the stages registered with this builder object. The composite aggregate operation places the results of the individual aggregate operations in an `ItemsByTag` and the `finishFn` you supply transforms it to the final result to emit. Use the tags you got from this builder in the implementation of `finishFn` to access the results.
      Type Parameters:
        `R` - the output item type
      Parameters:
        `finishFn` - the finishing function for the composite aggregate operation
      Returns:
        a new stage representing the co-aggregation

    - #### build

          @Nonnull
          public BatchStage<ItemsByTag> build()

      Creates and returns a pipeline stage that performs the co-aggregation of the stages registered with this builder object. The composite aggregate operation places the results of the individual aggregate operations in an `ItemsByTag`. Use the tags you got from this builder to access the results.
      Returns:
        a new stage representing the co-aggregation

Copyright © 2018. All rights reserved.