Package org.apache.storm.streams.processors

# Class CoGroupByKeyProcessor<K,V1,V2>

java.lang.Object
org.apache.storm.streams.processors.CoGroupByKeyProcessor<K,V1,V2>

All Implemented Interfaces:
  `Serializable`, `BatchProcessor`, `Processor<Pair<K,?>>`

public class CoGroupByKeyProcessor<K,V1,V2> extends Object implements BatchProcessor
co-group by key implementation.

See Also:
  - Serialized Form

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected ProcessorContext`
  `context`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `CoGroupByKeyProcessor(String firstStream, String secondStream)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `execute(Pair<K,?> input, String sourceStream)`
  Executes some operations on the input and possibly emits some results.
  `protected void`
  `execute(Pair<K,?> input)`
  Execute some operation on the input value.
  `void`
  `finish()`
  This is triggered to signal the end of the current batch of values.
  `void`
  `init(ProcessorContext context)`
  Initializes the processor.
  `protected final <R> void`
  `mayBeForwardAggUpdate(Supplier<R> result)`
  Forwards the result update to downstream processors.
  `void`
  `punctuate(String stream)`
  Punctuation marks end of a batch which can be used to compute and pass the results of one stage in the pipeline to the next.

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

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

- ## Field Details

  - ### context

    protected ProcessorContext context

- ## Constructor Details

  - ### CoGroupByKeyProcessor

    public CoGroupByKeyProcessor(String firstStream, String secondStream)

- ## Method Details

  - ### execute

    public void execute(Pair<K,?> input, String sourceStream)
    Executes some operations on the input and possibly emits some results. Processors that do not care about the source stream should override `BaseProcessor.execute(Object)` instead.
    Specified by:
      `execute` in interface `Processor<K>`
    Parameters:
      `input` - the input to be processed
      `sourceStream` - the source stream id from where the input is received

  - ### finish

    public void finish()
    This is triggered to signal the end of the current batch of values. Sub classes can override this to emit the result of a batch of values, for e.g. to emit the result of an aggregate or join operation on a batch of values. If a processor does per-value operation like filter, map etc, they can choose to ignore this.

  - ### init

    public void init(ProcessorContext context)
    Initializes the processor. This is typically invoked from the underlying storm bolt's prepare method.
    Specified by:
      `init` in interface `Processor<T>`
    Parameters:
      `context` - the processor context

  - ### execute

    protected void execute(Pair<K,?> input)
    Execute some operation on the input value. Sub classes can override this when then don't care about the source stream from where the input is received.
    Parameters:
      `input` - the input

  - ### punctuate

    public void punctuate(String stream)
    Punctuation marks end of a batch which can be used to compute and pass the results of one stage in the pipeline to the next. For e.g. emit the results of an aggregation.
    Specified by:
      `punctuate` in interface `Processor<T>`
    Parameters:
      `stream` - the stream id on which the punctuation arrived

  - ### mayBeForwardAggUpdate

    protected final <R> void mayBeForwardAggUpdate(Supplier<R> result)
    Forwards the result update to downstream processors. Processors that operate on a batch of tuples, like aggregation, join etc can use this to emit the partial results on each input if they are operating in non-windowed mode.
    Type Parameters:
      `R` - the result type
    Parameters:
      `result` - the result function