## cascading.tap
Class DecoratorTap<MetaInfo,Config,Input,Output>

    java.lang.Object
      cascading.tap.Tap<Config,Input,Output>
          cascading.tap.DecoratorTap<MetaInfo,Config,Input,Output>

All Implemented Interfaces:
  FlowElement, Traceable, Serializable

    public class DecoratorTap<MetaInfo,Config,Input,Output>

extends Tap<Config,Input,Output>

Class DecoratorTap wraps a given `Tap` instance, delegating all calls to the original.

It also provides an additional generic field that may hold any custom type, this allows implementations to attach any meta-info to the tap being decorated.

Further, sub-classes of DecoratorTap can be used to decorate any Tap instances associated or created for use by the `Checkpoint` `Pipe`.

Sub-classing this is optional if the aim is to simply attach relevant meta-info for use by a given application.

In order to pass any meta-info to a management service via the `Property` annotation, a sub-class of DecoratorTap must be provided.

See Also:
  Serialized Form

Field Summary
`protected MetaInfo` `metaInfo`
`protected Tap<Config,Input,Output>` `original`

Constructor Summary
`DecoratorTap(MetaInfo metaInfo, Tap<Config,Input,Output> original)` Creates a new Tap instance, wrapping the given Tap, and associates the given MetaInfo type with the wrapped Tap instance.
`DecoratorTap(Tap<Config,Input,Output> original)` Creates a new Tap instance, wrapping the given Tap, and associates the given MetaInfo type with the wrapped Tap instance.

Method Summary
`boolean` `commitResource(Config conf)` Method commitResource allows the underlying resource to be notified when all write processing is successful so that any additional cleanup or processing may be completed.
`boolean` `createResource(Config conf)` Method createResource creates the underlying resource.
`boolean` `createResource(FlowProcess<Config> flowProcess)` Method createResource creates the underlying resource.
`boolean` `deleteResource(Config conf)` Method deleteResource deletes the resource represented by this instance.
`boolean` `deleteResource(FlowProcess<Config> flowProcess)` Method deleteResource deletes the resource represented by this instance.
`void` `flowConfInit(Flow<Config> flow)` Method flowInit allows this Tap instance to initialize itself in context of the given `Flow` instance.
`ConfigDef` `getConfigDef()` Returns a `ConfigDef` instance that allows for local properties to be set and made available via a resulting `FlowProcess` instance when the tap is invoked.
`String` `getFullIdentifier(Config conf)` Method getFullIdentifier returns a fully qualified resource identifier.
`String` `getFullIdentifier(FlowProcess<Config> flowProcess)` Method getFullIdentifier returns a fully qualified resource identifier.
`String` `getIdentifier()` Method getIdentifier returns a String representing the resource this Tap instance represents.
`MetaInfo` `getMetaInfo()`
`long` `getModifiedTime(Config conf)` Method getModifiedTime returns the date this resource was last modified.
`long` `getModifiedTime(FlowProcess<Config> flowProcess)` Method getModifiedTime returns the date this resource was last modified.
`Tap<Config,Input,Output>` `getOriginal()`
`Scheme<Config,Input,Output,?,?>` `getScheme()` Method getScheme returns the scheme of this Tap object.
`Fields` `getSinkFields()` Method getSinkFields returns the sinkFields of this Tap object.
`SinkMode` `getSinkMode()` Method getSinkMode returns the `SinkMode` }of this Tap object.
`Fields` `getSourceFields()` Method getSourceFields returns the sourceFields of this Tap object.
`ConfigDef` `getStepConfigDef()` Returns a `ConfigDef` instance that allows for process level properties to be set and made available via a resulting `FlowProcess` instance when the tap is invoked.
`String` `getTrace()` Method getTrace returns a String that pinpoints the caller that created this instance.
`boolean` `hasConfigDef()` Returns `true` if there are properties in the configDef instance.
`boolean` `hasStepConfigDef()` Returns `true` if there are properties in the processConfigDef instance.
`boolean` `isEquivalentTo(FlowElement element)`
`boolean` `isKeep()` Method isKeep indicates whether the resource represented by this instance should be kept if it already exists when the Flow is started.
`boolean` `isReplace()` Method isReplace indicates whether the resource represented by this instance should be deleted if it already exists when the Flow is started.
`boolean` `isSink()` Method isSink returns true if this Tap instance can be used as a sink.
`boolean` `isSource()` Method isSource returns true if this Tap instance can be used as a source.
`boolean` `isTemporary()` Method isTemporary returns true if this Tap is temporary (used for intermediate results).
`boolean` `isUpdate()` Method isUpdate indicates whether the resource represented by this instance should be updated if it already exists.
`TupleEntryIterator` `openForRead(FlowProcess<Config> flowProcess)` Method openForRead opens the resource represented by this Tap instance for reading.
`TupleEntryIterator` `openForRead(FlowProcess<Config> flowProcess, Input input)` Method openForRead opens the resource represented by this Tap instance for reading.
`TupleEntryCollector` `openForWrite(FlowProcess<Config> flowProcess)` Method openForWrite opens the resource represented by this Tap instance for writing.
`TupleEntryCollector` `openForWrite(FlowProcess<Config> flowProcess, Output output)` Method openForWrite opens the resource represented by this Tap instance for writing.
`Scope` `outgoingScopeFor(Set<Scope> incomingScopes)` Method outgoingScopeFor returns the Scope this FlowElement hands off to the next FlowElement.
`void` `presentSinkFields(FlowProcess<Config> flowProcess, Fields fields)`
`void` `presentSourceFields(FlowProcess<Config> flowProcess, Fields fields)`
`Fields` `resolveIncomingOperationArgumentFields(Scope incomingScope)` Method resolveIncomingOperationArgumentFields returns the Fields outgoing from the previous FlowElement that are consumable by this FlowElement when preparing Operation arguments.
`Fields` `resolveIncomingOperationPassThroughFields(Scope incomingScope)` Method resolveIncomingOperationPassThroughFields returns the Fields outgoing from the previous FlowElement that are consumable by this FlowElement when preparing the Pipe outgoing tuple.
`boolean` `resourceExists(Config conf)` Method resourceExists returns true if the path represented by this instance exists.
`boolean` `resourceExists(FlowProcess<Config> flowProcess)` Method resourceExists returns true if the path represented by this instance exists.
`Fields` `retrieveSinkFields(FlowProcess<Config> flowProcess)` A hook for allowing a Scheme to lazily retrieve its sink fields.
`Fields` `retrieveSourceFields(FlowProcess<Config> flowProcess)` A hook for allowing a Scheme to lazily retrieve its source fields.
`boolean` `rollbackResource(Config conf)` Method rollbackResource allows the underlying resource to be notified when any write processing has failed or was stopped so that any cleanup may be started.
`protected void` `setMetaInfo(MetaInfo metaInfo)`
`protected void` `setOriginal(Tap<Config,Input,Output> original)`
`void` `sinkConfInit(FlowProcess<Config> flowProcess, Config conf)` Method sinkConfInit initializes this instance as a sink.
`void` `sourceConfInit(FlowProcess<Config> flowProcess, Config conf)` Method sourceConfInit initializes this instance as a source.
`String` `toString()`

Methods inherited from class cascading.tap.Tap
`equals, hashCode, id, setScheme, taps`

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

Field Detail

### metaInfo

    protected MetaInfo metaInfo

### original

    protected Tap<Config,Input,Output> original

Constructor Detail

### DecoratorTap

    @ConstructorProperties(value={"metaInfo","original"})
    public DecoratorTap(MetaInfo metaInfo,
                                                   Tap<Config,Input,Output> original)

  Creates a new Tap instance, wrapping the given Tap, and associates the given MetaInfo type with the wrapped Tap instance.

  Parameters:
    `metaInfo` - meta-information about the current Tap
    `original` - the decorated Tap instance

### DecoratorTap

    @ConstructorProperties(value="original")
    public DecoratorTap(Tap<Config,Input,Output> original)

  Creates a new Tap instance, wrapping the given Tap, and associates the given MetaInfo type with the wrapped Tap instance.

  Parameters:
    `original` - the decorated Tap instance

Method Detail

### getMetaInfo

    public MetaInfo getMetaInfo()

### getOriginal

    public Tap<Config,Input,Output> getOriginal()

### setOriginal

    protected void setOriginal(Tap<Config,Input,Output> original)

### setMetaInfo

    protected void setMetaInfo(MetaInfo metaInfo)

### getScheme

    public Scheme<Config,Input,Output,?,?> getScheme()

  Description copied from class: `Tap`
  Method getScheme returns the scheme of this Tap object.

  Overrides:
    `getScheme` in class `Tap<Config,Input,Output>`
  Returns:
    the scheme (type Scheme) of this Tap object.

### getTrace

    public String getTrace()

  Description copied from interface: `Traceable`
  Method getTrace returns a String that pinpoints the caller that created this instance.

  Specified by:
    `getTrace` in interface `Traceable`
  Overrides:
    `getTrace` in class `Tap<Config,Input,Output>`
  Returns:
    String

### flowConfInit

    public void flowConfInit(Flow<Config> flow)

  Description copied from class: `Tap`
  Method flowInit allows this Tap instance to initialize itself in context of the given `Flow` instance. This method is guaranteed to be called before the Flow is started and the `FlowListener.onStarting(cascading.flow.Flow)` event is fired.

  This method will be called once per Flow, and before `Tap.sourceConfInit(cascading.flow.FlowProcess, Object)` and `Tap.sinkConfInit(cascading.flow.FlowProcess, Object)` methods.

  Overrides:
    `flowConfInit` in class `Tap<Config,Input,Output>`
  Parameters:
    `flow` - of type Flow

### sourceConfInit

    public void sourceConfInit(FlowProcess<Config> flowProcess,
                               Config conf)

  Description copied from class: `Tap`
  Method sourceConfInit initializes this instance as a source.

  This method maybe called more than once if this Tap instance is used outside the scope of a `Flow` instance or if it participates in multiple times in a given Flow or across different Flows in a `Cascade`.

  In the context of a Flow, it will be called after `FlowListener.onStarting(cascading.flow.Flow)`

  Note that no resources or services should be modified by this method.

  Overrides:
    `sourceConfInit` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
    `conf` - of type Config

### sinkConfInit

    public void sinkConfInit(FlowProcess<Config> flowProcess,
                             Config conf)

  Description copied from class: `Tap`
  Method sinkConfInit initializes this instance as a sink.

  This method maybe called more than once if this Tap instance is used outside the scope of a `Flow` instance or if it participates in multiple times in a given Flow or across different Flows in a `Cascade`.

  Note this method will be called in context of this Tap being used as a traditional 'sink' and as a 'trap'.

  In the context of a Flow, it will be called after `FlowListener.onStarting(cascading.flow.Flow)`

  Note that no resources or services should be modified by this method. If this Tap instance returns true for `Tap.isReplace()`, then `Tap.deleteResource(Object)` will be called by the parent Flow.

  Overrides:
    `sinkConfInit` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
    `conf` - of type Config

### getIdentifier

    public String getIdentifier()

  Description copied from class: `Tap`
  Method getIdentifier returns a String representing the resource this Tap instance represents.

  Often, if the tap accesses a filesystem, the identifier is nothing more than the path to the file or directory. In other cases it may be a an URL or URI representing a connection string or remote resource.

  Any two Tap instances having the same value for the identifier are considered equal.

  Specified by:
    `getIdentifier` in class `Tap<Config,Input,Output>`
  Returns:
    String

### getSourceFields

    public Fields getSourceFields()

  Description copied from class: `Tap`
  Method getSourceFields returns the sourceFields of this Tap object.

  Overrides:
    `getSourceFields` in class `Tap<Config,Input,Output>`
  Returns:
    the sourceFields (type Fields) of this Tap object.

### getSinkFields

    public Fields getSinkFields()

  Description copied from class: `Tap`
  Method getSinkFields returns the sinkFields of this Tap object.

  Overrides:
    `getSinkFields` in class `Tap<Config,Input,Output>`
  Returns:
    the sinkFields (type Fields) of this Tap object.

### openForRead

    public TupleEntryIterator openForRead(FlowProcess<Config> flowProcess,
                                          Input input)
                                   throws IOException

  Description copied from class: `Tap`
  Method openForRead opens the resource represented by this Tap instance for reading.

  `input` value may be null, if so, sub-classes must inquire with the underlying `Scheme` via `Scheme.sourceConfInit(cascading.flow.FlowProcess, Tap, Object)` to get the proper input type and instantiate it before calling `super.openForRead()`.

  Note the returned iterator will return the same instance of `TupleEntry` on every call, thus a copy must be made of either the TupleEntry or the underlying `Tuple` instance if they are to be stored in a Collection.

  Specified by:
    `openForRead` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
    `input` - of type Input
  Returns:
    TupleEntryIterator
  Throws:
    `IOException` - when the resource cannot be opened

### openForRead

    public TupleEntryIterator openForRead(FlowProcess<Config> flowProcess)
                                   throws IOException

  Description copied from class: `Tap`
  Method openForRead opens the resource represented by this Tap instance for reading.

  Note the returned iterator will return the same instance of `TupleEntry` on every call, thus a copy must be made of either the TupleEntry or the underlying `Tuple` instance if they are to be stored in a Collection.

  Overrides:
    `openForRead` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    TupleEntryIterator
  Throws:
    `IOException` - when the resource cannot be opened

### openForWrite

    public TupleEntryCollector openForWrite(FlowProcess<Config> flowProcess,
                                            Output output)
                                     throws IOException

  Description copied from class: `Tap`
  Method openForWrite opens the resource represented by this Tap instance for writing.

  This method is used internally and does not honor the `SinkMode` setting. If SinkMode is `SinkMode.REPLACE`, this call may fail. See `Tap.openForWrite(cascading.flow.FlowProcess)`.

  `output` value may be null, if so, sub-classes must inquire with the underlying `Scheme` via `Scheme.sinkConfInit(cascading.flow.FlowProcess, Tap, Object)` to get the proper output type and instantiate it before calling `super.openForWrite()`.

  Specified by:
    `openForWrite` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
    `output` - of type Output
  Returns:
    TupleEntryCollector
  Throws:
    `IOException` - when the resource cannot be opened

### openForWrite

    public TupleEntryCollector openForWrite(FlowProcess<Config> flowProcess)
                                     throws IOException

  Description copied from class: `Tap`
  Method openForWrite opens the resource represented by this Tap instance for writing.

  This method is for user application use and does honor the `SinkMode.REPLACE` settings. That is, if SinkMode is set to `SinkMode.REPLACE` the underlying resource will be deleted.

  Note if `SinkMode.UPDATE` is set, the resource will not be deleted.

  Overrides:
    `openForWrite` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    TupleEntryCollector
  Throws:
    `IOException` - when the resource cannot be opened

### outgoingScopeFor

    public Scope outgoingScopeFor(Set<Scope> incomingScopes)

  Description copied from interface: `FlowElement`
  Method outgoingScopeFor returns the Scope this FlowElement hands off to the next FlowElement.

  Specified by:
    `outgoingScopeFor` in interface `FlowElement`
  Overrides:
    `outgoingScopeFor` in class `Tap<Config,Input,Output>`
  Parameters:
    `incomingScopes` - of type Set<Scope>
  Returns:
    Scope

### retrieveSourceFields

    public Fields retrieveSourceFields(FlowProcess<Config> flowProcess)

  Description copied from class: `Tap`
  A hook for allowing a Scheme to lazily retrieve its source fields.

  Overrides:
    `retrieveSourceFields` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    the found Fields

### presentSourceFields

    public void presentSourceFields(FlowProcess<Config> flowProcess,
                                    Fields fields)

  Overrides:
    `presentSourceFields` in class `Tap<Config,Input,Output>`

### retrieveSinkFields

    public Fields retrieveSinkFields(FlowProcess<Config> flowProcess)

  Description copied from class: `Tap`
  A hook for allowing a Scheme to lazily retrieve its sink fields.

  Overrides:
    `retrieveSinkFields` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    the found Fields

### presentSinkFields

    public void presentSinkFields(FlowProcess<Config> flowProcess,
                                  Fields fields)

  Overrides:
    `presentSinkFields` in class `Tap<Config,Input,Output>`

### resolveIncomingOperationArgumentFields

    public Fields resolveIncomingOperationArgumentFields(Scope incomingScope)

  Description copied from interface: `FlowElement`
  Method resolveIncomingOperationArgumentFields returns the Fields outgoing from the previous FlowElement that are consumable by this FlowElement when preparing Operation arguments.

  Specified by:
    `resolveIncomingOperationArgumentFields` in interface `FlowElement`
  Overrides:
    `resolveIncomingOperationArgumentFields` in class `Tap<Config,Input,Output>`
  Parameters:
    `incomingScope` - of type Scope
  Returns:
    Fields

### resolveIncomingOperationPassThroughFields

    public Fields resolveIncomingOperationPassThroughFields(Scope incomingScope)

  Description copied from interface: `FlowElement`
  Method resolveIncomingOperationPassThroughFields returns the Fields outgoing from the previous FlowElement that are consumable by this FlowElement when preparing the Pipe outgoing tuple.

  Specified by:
    `resolveIncomingOperationPassThroughFields` in interface `FlowElement`
  Overrides:
    `resolveIncomingOperationPassThroughFields` in class `Tap<Config,Input,Output>`
  Parameters:
    `incomingScope` - of type Scope
  Returns:
    Fields

### getFullIdentifier

    public String getFullIdentifier(FlowProcess<Config> flowProcess)

  Description copied from class: `Tap`
  Method getFullIdentifier returns a fully qualified resource identifier.

  Overrides:
    `getFullIdentifier` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    String

### getFullIdentifier

    public String getFullIdentifier(Config conf)

  Description copied from class: `Tap`
  Method getFullIdentifier returns a fully qualified resource identifier.

  Overrides:
    `getFullIdentifier` in class `Tap<Config,Input,Output>`
  Parameters:
    `conf` - of type Config
  Returns:
    String

### createResource

    public boolean createResource(FlowProcess<Config> flowProcess)
                           throws IOException

  Description copied from class: `Tap`
  Method createResource creates the underlying resource.

  Overrides:
    `createResource` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    boolean
  Throws:
    `IOException` - when there is an error making directories

### createResource

    public boolean createResource(Config conf)
                           throws IOException

  Description copied from class: `Tap`
  Method createResource creates the underlying resource.

  Specified by:
    `createResource` in class `Tap<Config,Input,Output>`
  Parameters:
    `conf` - of type Config
  Returns:
    boolean
  Throws:
    `IOException` - when there is an error making directories

### deleteResource

    public boolean deleteResource(FlowProcess<Config> flowProcess)
                           throws IOException

  Description copied from class: `Tap`
  Method deleteResource deletes the resource represented by this instance.

  Overrides:
    `deleteResource` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    boolean
  Throws:
    `IOException` - when the resource cannot be deleted

### deleteResource

    public boolean deleteResource(Config conf)
                           throws IOException

  Description copied from class: `Tap`
  Method deleteResource deletes the resource represented by this instance.

  Specified by:
    `deleteResource` in class `Tap<Config,Input,Output>`
  Parameters:
    `conf` - of type Config
  Returns:
    boolean
  Throws:
    `IOException` - when the resource cannot be deleted

### commitResource

    public boolean commitResource(Config conf)
                           throws IOException

  Description copied from class: `Tap`
  Method commitResource allows the underlying resource to be notified when all write processing is successful so that any additional cleanup or processing may be completed.

  See `Tap.rollbackResource(Object)` to handle cleanup in the face of failures.

  This method is invoked once "client side" and not in the cluster, if any.

  If other sink Tap instance in a given Flow fail on commitResource after called on this instance, rollbackResource will not be called.

  <emphasis>This is an experimental API and subject to refinement!!</emphasis>

  Overrides:
    `commitResource` in class `Tap<Config,Input,Output>`
  Parameters:
    `conf` - of type Config
  Returns:
    returns true if successful
  Throws:
    `IOException`

### rollbackResource

    public boolean rollbackResource(Config conf)
                             throws IOException

  Description copied from class: `Tap`
  Method rollbackResource allows the underlying resource to be notified when any write processing has failed or was stopped so that any cleanup may be started.

  See `Tap.commitResource(Object)` to handle cleanup when the write has successfully completed.

  This method is invoked once "client side" and not in the cluster, if any.

  <emphasis>This is an experimental API and subject to refinement!!</emphasis>

  Overrides:
    `rollbackResource` in class `Tap<Config,Input,Output>`
  Parameters:
    `conf` - of type Config
  Returns:
    returns true if successful
  Throws:
    `IOException`

### resourceExists

    public boolean resourceExists(FlowProcess<Config> flowProcess)
                           throws IOException

  Description copied from class: `Tap`
  Method resourceExists returns true if the path represented by this instance exists.

  Overrides:
    `resourceExists` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    true if the underlying resource already exists
  Throws:
    `IOException` - when the status cannot be determined

### resourceExists

    public boolean resourceExists(Config conf)
                           throws IOException

  Description copied from class: `Tap`
  Method resourceExists returns true if the path represented by this instance exists.

  Specified by:
    `resourceExists` in class `Tap<Config,Input,Output>`
  Parameters:
    `conf` - of type Config
  Returns:
    true if the underlying resource already exists
  Throws:
    `IOException` - when the status cannot be determined

### getModifiedTime

    public long getModifiedTime(FlowProcess<Config> flowProcess)
                         throws IOException

  Description copied from class: `Tap`
  Method getModifiedTime returns the date this resource was last modified.

  Overrides:
    `getModifiedTime` in class `Tap<Config,Input,Output>`
  Parameters:
    `flowProcess` - of type FlowProcess
  Returns:
    The date this resource was last modified.
  Throws:
    `IOException`

### getModifiedTime

    public long getModifiedTime(Config conf)
                         throws IOException

  Description copied from class: `Tap`
  Method getModifiedTime returns the date this resource was last modified.

  Specified by:
    `getModifiedTime` in class `Tap<Config,Input,Output>`
  Parameters:
    `conf` - of type Config
  Returns:
    The date this resource was last modified.
  Throws:
    `IOException`

### getSinkMode

    public SinkMode getSinkMode()

  Description copied from class: `Tap`
  Method getSinkMode returns the `SinkMode` }of this Tap object.

  Overrides:
    `getSinkMode` in class `Tap<Config,Input,Output>`
  Returns:
    the sinkMode (type SinkMode) of this Tap object.

### isKeep

    public boolean isKeep()

  Description copied from class: `Tap`
  Method isKeep indicates whether the resource represented by this instance should be kept if it already exists when the Flow is started.

  Overrides:
    `isKeep` in class `Tap<Config,Input,Output>`
  Returns:
    boolean

### isReplace

    public boolean isReplace()

  Description copied from class: `Tap`
  Method isReplace indicates whether the resource represented by this instance should be deleted if it already exists when the Flow is started.

  Overrides:
    `isReplace` in class `Tap<Config,Input,Output>`
  Returns:
    boolean

### isUpdate

    public boolean isUpdate()

  Description copied from class: `Tap`
  Method isUpdate indicates whether the resource represented by this instance should be updated if it already exists. Otherwise a new resource will be created, via `Tap.createResource(Object)`, when the Flow is started.

  Overrides:
    `isUpdate` in class `Tap<Config,Input,Output>`
  Returns:
    boolean

### isSink

    public boolean isSink()

  Description copied from class: `Tap`
  Method isSink returns true if this Tap instance can be used as a sink.

  Overrides:
    `isSink` in class `Tap<Config,Input,Output>`
  Returns:
    boolean

### isSource

    public boolean isSource()

  Description copied from class: `Tap`
  Method isSource returns true if this Tap instance can be used as a source.

  Overrides:
    `isSource` in class `Tap<Config,Input,Output>`
  Returns:
    boolean

### isTemporary

    public boolean isTemporary()

  Description copied from class: `Tap`
  Method isTemporary returns true if this Tap is temporary (used for intermediate results).

  Overrides:
    `isTemporary` in class `Tap<Config,Input,Output>`
  Returns:
    the temporary (type boolean) of this Tap object.

### getConfigDef

    public ConfigDef getConfigDef()

  Description copied from class: `Tap`
  Returns a `ConfigDef` instance that allows for local properties to be set and made available via a resulting `FlowProcess` instance when the tap is invoked.

  Any properties set on the configDef will not show up in any `Flow` or `FlowStep` process level configuration, but will override any of those values as seen by the current Tap instance method call where a FlowProcess is provided except for the `Tap.sourceConfInit(cascading.flow.FlowProcess, Object)` and `Tap.sinkConfInit(cascading.flow.FlowProcess, Object)` methods.

  That is, the `*confInit` methods are called before any ConfigDef is applied, so any values placed into a ConfigDef instance will not be visible to them.

  Specified by:
    `getConfigDef` in interface `FlowElement`
  Overrides:
    `getConfigDef` in class `Tap<Config,Input,Output>`
  Returns:
    an instance of ConfigDef

### hasConfigDef

    public boolean hasConfigDef()

  Description copied from class: `Tap`
  Returns `true` if there are properties in the configDef instance.

  Specified by:
    `hasConfigDef` in interface `FlowElement`
  Overrides:
    `hasConfigDef` in class `Tap<Config,Input,Output>`
  Returns:
    true if there are configDef properties

### getStepConfigDef

    public ConfigDef getStepConfigDef()

  Description copied from class: `Tap`
  Returns a `ConfigDef` instance that allows for process level properties to be set and made available via a resulting `FlowProcess` instance when the tap is invoked.

  Any properties set on the stepConfigDef will not show up in any Flow configuration, but will show up in the current process `FlowStep` (in Hadoop the MapReduce jobconf). Any value set in the stepConfigDef will be overridden by the tap local `#getConfigDef` instance. Use this method to tweak properties in the process step this tap instance is planned into.

  Note the `*confInit` methods are called before any ConfigDef is applied, so any values placed into a ConfigDef instance will not be visible to them.

  Specified by:
    `getStepConfigDef` in interface `FlowElement`
  Overrides:
    `getStepConfigDef` in class `Tap<Config,Input,Output>`
  Returns:
    an instance of ConfigDef

### hasStepConfigDef

    public boolean hasStepConfigDef()

  Description copied from class: `Tap`
  Returns `true` if there are properties in the processConfigDef instance.

  Specified by:
    `hasStepConfigDef` in interface `FlowElement`
  Overrides:
    `hasStepConfigDef` in class `Tap<Config,Input,Output>`
  Returns:
    true if there are processConfigDef properties

### isEquivalentTo

    public boolean isEquivalentTo(FlowElement element)

  Specified by:
    `isEquivalentTo` in interface `FlowElement`
  Overrides:
    `isEquivalentTo` in class `Tap<Config,Input,Output>`

### toString

    public String toString()

  Overrides:
    `toString` in class `Tap<Config,Input,Output>`

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