cascading.pipe.assembly

## Class AggregateBy.CompositeFunction

- java.lang.Object
- - cascading.operation.BaseOperation<AggregateBy.CompositeFunction.Context>
  - - cascading.pipe.assembly.AggregateBy.CompositeFunction

- All Implemented Interfaces:
    DeclaresResults, Function<AggregateBy.CompositeFunction.Context>, Operation<AggregateBy.CompositeFunction.Context>, Traceable, java.io.Serializable
  Enclosing class:
    AggregateBy

      public static class AggregateBy.CompositeFunction
      extends BaseOperation<AggregateBy.CompositeFunction.Context>
      implements Function<AggregateBy.CompositeFunction.Context>

  Class CompositeFunction takes multiple Functor instances and manages them as a single `Function`.
  See Also:
    `AggregateBy.Functor`, Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `AggregateBy.CompositeFunction.Context`

  - ### Field Summary

    - ### Fields inherited from class cascading.operation.BaseOperation

      `fieldDeclaration, numArgs, trace`

    - ### Fields inherited from interface cascading.operation.Operation

      `ANY`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AggregateBy.CompositeFunction(Fields groupingFields, Fields[] argumentFields, AggregateBy.Functor[] functors, int capacity)` Constructor CompositeFunction creates a new CompositeFunction instance.
    `AggregateBy.CompositeFunction(Fields groupingFields, Fields argumentFields, AggregateBy.Functor functor, int capacity)` Constructor CompositeFunction creates a new CompositeFunction instance.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `cleanup(FlowProcess flowProcess, OperationCall<AggregateBy.CompositeFunction.Context> operationCall)` Method cleanup does nothing, and may safely be overridden.
    `boolean` | `equals(java.lang.Object object)`
    `void` | `flush(FlowProcess flowProcess, OperationCall<AggregateBy.CompositeFunction.Context> operationCall)` The flush method is called when an Operation that is caching values must empty the cache.
    `int` | `hashCode()`
    `void` | `operate(FlowProcess flowProcess, FunctionCall<AggregateBy.CompositeFunction.Context> functionCall)` Method operate provides the implementation of this Function.
    `void` | `prepare(FlowProcess flowProcess, OperationCall<AggregateBy.CompositeFunction.Context> operationCall)` Method prepare does nothing, and may safely be overridden.

    - ### Methods inherited from class cascading.operation.BaseOperation

      `getFieldDeclaration, getNumArgs, getTrace, isSafe, printOperationInternal, toString, toStringInternal`

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface cascading.operation.Operation

      `getFieldDeclaration, getNumArgs, isSafe`

- - ### Constructor Detail

    - #### AggregateBy.CompositeFunction

          public AggregateBy.CompositeFunction(Fields groupingFields,
                                       Fields argumentFields,
                                       AggregateBy.Functor functor,
                                       int capacity)

      Constructor CompositeFunction creates a new CompositeFunction instance.
      Parameters:
        `groupingFields` - of type Fields
        `argumentFields` - of type Fields
        `functor` - of type Functor
        `capacity` - of type int

    - #### AggregateBy.CompositeFunction

          public AggregateBy.CompositeFunction(Fields groupingFields,
                                       Fields[] argumentFields,
                                       AggregateBy.Functor[] functors,
                                       int capacity)

      Constructor CompositeFunction creates a new CompositeFunction instance.
      Parameters:
        `groupingFields` - of type Fields
        `argumentFields` - of type Fields[]
        `functors` - of type Functor[]
        `capacity` - of type int

  - ### Method Detail

    - #### prepare

          public void prepare(FlowProcess flowProcess,
                     OperationCall<AggregateBy.CompositeFunction.Context> operationCall)

      Description copied from class: `BaseOperation`
      Method prepare does nothing, and may safely be overridden.
      Specified by:
        `prepare` in interface `Operation<AggregateBy.CompositeFunction.Context>`
      Overrides:
        `prepare` in class `BaseOperation<AggregateBy.CompositeFunction.Context>`

    - #### operate

          public void operate(FlowProcess flowProcess,
                     FunctionCall<AggregateBy.CompositeFunction.Context> functionCall)

      Description copied from interface: `Function`
      Method operate provides the implementation of this Function.
      Specified by:
        `operate` in interface `Function<AggregateBy.CompositeFunction.Context>`
      Parameters:
        `flowProcess` - of type FlowProcess
        `functionCall` - of type FunctionCall

    - #### flush

          public void flush(FlowProcess flowProcess,
                   OperationCall<AggregateBy.CompositeFunction.Context> operationCall)

      Description copied from interface: `Operation`
      The flush method is called when an Operation that is caching values must empty the cache. It is called before `Operation.cleanup(cascading.flow.FlowProcess, OperationCall)` is invoked.

      It is safe to cast the `OperationCall` to a `FunctionCall`, or equivalent, and get its `FunctionCall.getOutputCollector()`.
      Specified by:
        `flush` in interface `Operation<AggregateBy.CompositeFunction.Context>`
      Overrides:
        `flush` in class `BaseOperation<AggregateBy.CompositeFunction.Context>`

    - #### cleanup

          public void cleanup(FlowProcess flowProcess,
                     OperationCall<AggregateBy.CompositeFunction.Context> operationCall)

      Description copied from class: `BaseOperation`
      Method cleanup does nothing, and may safely be overridden.
      Specified by:
        `cleanup` in interface `Operation<AggregateBy.CompositeFunction.Context>`
      Overrides:
        `cleanup` in class `BaseOperation<AggregateBy.CompositeFunction.Context>`

    - #### equals

          public boolean equals(java.lang.Object object)

      Overrides:
        `equals` in class `BaseOperation<AggregateBy.CompositeFunction.Context>`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `BaseOperation<AggregateBy.CompositeFunction.Context>`

Copyright © 2007-2015 Xplenty, Inc. All Rights Reserved.