## cascading.flow.stream
Class OperatorStage<Incoming>

    java.lang.Object
      cascading.flow.stream.Duct<Incoming,Outgoing>
          cascading.flow.stream.Stage<Incoming,Outgoing>
              cascading.flow.stream.ElementStage<Incoming,TupleEntry>
                  cascading.flow.stream.OperatorStage<Incoming>

All Implemented Interfaces:
  ElementDuct

Direct Known Subclasses:
  EachStage, EveryStage

    public abstract class OperatorStage<Incoming>

extends ElementStage<Incoming,TupleEntry>

Field Summary
`protected TupleBuilder` `argumentsBuilder`
`protected TupleEntry` `argumentsEntry`
`protected Fields` `argumentsSelector`
`protected TupleEntry` `incomingEntry`
`protected ConcreteCall` `operationCall`
`protected TupleBuilder` `outgoingBuilder`
`protected TupleEntry` `outgoingEntry`
`protected Fields` `outgoingSelector`
`protected TupleEntryCollector` `outputCollector`
`protected Fields` `remainderFields`
`static String` `RETAIN_COLLECTOR` In 2.2 the collector is now nulled before the `Operation.cleanup(cascading.flow.FlowProcess, cascading.operation.OperationCall)` is called.

Fields inherited from class cascading.flow.stream.ElementStage
`branchNames, flowElement, flowProcess, incomingScopes, outgoingScopes, trapHandler`

Fields inherited from class cascading.flow.stream.Duct
`next`

Constructor Summary
`OperatorStage(FlowProcess flowProcess, FlowElement flowElement)`

Method Summary
`void` `cleanup()`
`void` `complete(Duct previous)`
`protected TupleBuilder` `createArgumentsBuilder(Fields incomingFields, Fields argumentsSelector)`
`protected TupleBuilder` `createOutgoingBuilder(Operator operator, Fields incomingFields, Fields argumentSelector, Fields remainderFields, Fields declaredFields, Fields outgoingSelector)`
`protected abstract Fields` `getIncomingArgumentsFields()`
`protected abstract Fields` `getIncomingPassThroughFields()`
`protected Fields` `getOperationDeclaredFields()`
`abstract Operator` `getOperator()`
`protected abstract Fields` `getOutgoingSelector()`
`void` `initialize()` Called immediately after bind
`void` `prepare()`

Methods inherited from class cascading.flow.stream.ElementStage
`addIncomingScope, addOutgoingScope, equals, getBranchNames, getFlowElement, getIncomingScopes, getOutgoingFields, getOutgoingScopes, handleException, handleReThrowableException, hashCode, hasTrapHandler, setBranchNames, setTrapHandler, toString`

Methods inherited from class cascading.flow.stream.Stage
`receive`

Methods inherited from class cascading.flow.stream.Duct
`bind, getNext, getNextFor, receiveFirst, start`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### RETAIN_COLLECTOR

    public static final String RETAIN_COLLECTOR

  In 2.2 the collector is now nulled before the `Operation.cleanup(cascading.flow.FlowProcess, cascading.operation.OperationCall)` is called. This property retains the collector to remain compatible with 2.1.

  See Also:
    Constant Field Values

### operationCall

    protected ConcreteCall operationCall

### incomingEntry

    protected TupleEntry incomingEntry

### argumentsSelector

    protected Fields argumentsSelector

### argumentsEntry

    protected TupleEntry argumentsEntry

### remainderFields

    protected Fields remainderFields

### outgoingSelector

    protected Fields outgoingSelector

### outgoingEntry

    protected TupleEntry outgoingEntry

### argumentsBuilder

    protected TupleBuilder argumentsBuilder

### outgoingBuilder

    protected TupleBuilder outgoingBuilder

### outputCollector

    protected TupleEntryCollector outputCollector

Constructor Detail

### OperatorStage

    public OperatorStage(FlowProcess flowProcess,
                         FlowElement flowElement)

Method Detail

### getOperator

    public abstract Operator getOperator()

### getOutgoingSelector

    protected abstract Fields getOutgoingSelector()

### getOperationDeclaredFields

    protected Fields getOperationDeclaredFields()

### getIncomingPassThroughFields

    protected abstract Fields getIncomingPassThroughFields()

### getIncomingArgumentsFields

    protected abstract Fields getIncomingArgumentsFields()

### createArgumentsBuilder

    protected TupleBuilder createArgumentsBuilder(Fields incomingFields,
                                                  Fields argumentsSelector)

### createOutgoingBuilder

    protected TupleBuilder createOutgoingBuilder(Operator operator,
                                                 Fields incomingFields,
                                                 Fields argumentSelector,
                                                 Fields remainderFields,
                                                 Fields declaredFields,
                                                 Fields outgoingSelector)

### initialize

    public void initialize()

  Description copied from class: `Duct`
  Called immediately after bind

  Overrides:
    `initialize` in class `Duct<Incoming,TupleEntry>`

### prepare

    public void prepare()

  Overrides:
    `prepare` in class `Duct<Incoming,TupleEntry>`

### complete

    public void complete(Duct previous)

  Overrides:
    `complete` in class `Duct<Incoming,TupleEntry>`

### cleanup

    public void cleanup()

  Overrides:
    `cleanup` in class `ElementStage<Incoming,TupleEntry>`

Copyright © 2007-2014 Concurrent, Inc. All Rights Reserved.