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, ScopedElement, 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

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected MetaInfo` | `metaInfo`
    `protected Tap<Config,Input,Output>` | `original`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `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

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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<? extends Config> flowProcess)` Method createResource creates the underlying resource.
    `boolean` | `deleteResource(Config conf)` Method deleteResource deletes the resource represented by this instance.
    `boolean` | `deleteResource(FlowProcess<? extends 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<? extends 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<? extends Config> flowProcess)` Method getModifiedTime returns the date this resource was last modified.
    `ConfigDef` | `getNodeConfigDef()` 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.
    `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` | `hasNodeConfigDef()` Returns `true` if there are properties in the nodeConfigDef instance.
    `boolean` | `hasStepConfigDef()` Returns `true` if there are properties in the stepConfigDef instance.
    `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<? extends Config> flowProcess)` Method openForRead opens the resource represented by this Tap instance for reading.
    `TupleEntryIterator` | `openForRead(FlowProcess<? extends Config> flowProcess, Input input)` Method openForRead opens the resource represented by this Tap instance for reading.
    `TupleEntryCollector` | `openForWrite(FlowProcess<? extends Config> flowProcess)` Method openForWrite opens the resource represented by this Tap instance for writing.
    `TupleEntryCollector` | `openForWrite(FlowProcess<? extends 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.
    `boolean` | `prepareResourceForRead(Config conf)` Method prepareResourceForRead allows the underlying resource to be notified when reading will begin.
    `boolean` | `prepareResourceForWrite(Config conf)` Method prepareResourceForWrite allows the underlying resource to be notified when writing will begin.
    `void` | `presentSinkFields(FlowProcess<? extends Config> flowProcess, Fields fields)`
    `void` | `presentSourceFields(FlowProcess<? extends 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<? extends Config> flowProcess)` Method resourceExists returns true if the path represented by this instance exists.
    `Fields` | `retrieveSinkFields(FlowProcess<? extends Config> flowProcess)` A hook for allowing a Scheme to lazily retrieve its sink fields.
    `Fields` | `retrieveSourceFields(FlowProcess<? extends 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<? extends Config> flowProcess, Config conf)` Method sinkConfInit initializes this instance as a sink.
    `void` | `sourceConfInit(FlowProcess<? extends 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<? extends 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<? extends 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<? extends 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<? extends 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<? extends 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<? extends 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: `ScopedElement`
      Method outgoingScopeFor returns the Scope this FlowElement hands off to the next FlowElement.
      Specified by:
        `outgoingScopeFor` in interface `ScopedElement`
      Overrides:
        `outgoingScopeFor` in class `Tap<Config,Input,Output>`
      Parameters:
        `incomingScopes` - of type Set
      Returns:
        Scope

    - #### retrieveSourceFields

          public Fields retrieveSourceFields(FlowProcess<? extends 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<? extends Config> flowProcess,
                                 Fields fields)

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

    - #### retrieveSinkFields

          public Fields retrieveSinkFields(FlowProcess<? extends 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<? extends Config> flowProcess,
                               Fields fields)

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

    - #### resolveIncomingOperationArgumentFields

          public Fields resolveIncomingOperationArgumentFields(Scope incomingScope)

      Description copied from interface: `ScopedElement`
      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 `ScopedElement`
      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: `ScopedElement`
      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 `ScopedElement`
      Overrides:
        `resolveIncomingOperationPassThroughFields` in class `Tap<Config,Input,Output>`
      Parameters:
        `incomingScope` - of type Scope
      Returns:
        Fields

    - #### getFullIdentifier

          public String getFullIdentifier(FlowProcess<? extends 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<? extends 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<? extends 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

    - #### prepareResourceForRead

          public boolean prepareResourceForRead(Config conf)
                                         throws IOException

      Description copied from class: `Tap`
      Method prepareResourceForRead allows the underlying resource to be notified when reading will begin.

      This method will be called client side so that any remote or external resources can be initialized.

      If this method returns `false`, an exception will be thrown halting the current Flow.

      In most cases, resource initialization should happen in the `Tap.openForRead(FlowProcess, Object)` method.

      This allows for initialization of cluster side resources, like a JDBC driver used to read data from a database, that cannot be passed client to cluster.
      Overrides:
        `prepareResourceForRead` in class `Tap<Config,Input,Output>`
      Parameters:
        `conf` - of type Config
      Returns:
        returns true if successful
      Throws:
        `IOException`

    - #### prepareResourceForWrite

          public boolean prepareResourceForWrite(Config conf)
                                          throws IOException

      Description copied from class: `Tap`
      Method prepareResourceForWrite allows the underlying resource to be notified when writing will begin.

      This method will be called once client side so that any remote or external resources can be initialized.

      If this method returns `false`, an exception will be thrown halting the current Flow.

      In most cases, resource initialization should happen in the `Tap.openForWrite(FlowProcess, Object)` method.

      This allows for initialization of cluster side resources, like a JDBC driver used to write data to a database, that cannot be passed client to cluster.

      In the above JDBC example, overriding this method will allow for testing for the existence of and/or creating a remote table used by all individual cluster side tasks.
      Overrides:
        `prepareResourceForWrite` in class `Tap<Config,Input,Output>`
      Parameters:
        `conf` - of type Config
      Returns:
        returns true if successful
      Throws:
        `IOException`

    - #### 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.
      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.
      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<? extends 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<? extends 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 `ScopedElement`
      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 `ScopedElement`
      Overrides:
        `hasConfigDef` in class `Tap<Config,Input,Output>`
      Returns:
        true if there are configDef properties

    - #### getNodeConfigDef

          public ConfigDef getNodeConfigDef()

      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 nodeConfigDef will not show up in any Flow configuration, but will show up in the current process `FlowNode` (in Apache Tez the Vertex configuration). Any value set in the nodeConfigDef will be overridden by the pipe local `#getConfigDef` instance. Use this method to tweak properties in the process node this tap instance is planned into.
      Specified by:
        `getNodeConfigDef` in interface `ScopedElement`
      Overrides:
        `getNodeConfigDef` in class `Tap<Config,Input,Output>`
      Returns:
        an instance of ConfigDef

    - #### hasNodeConfigDef

          public boolean hasNodeConfigDef()

      Description copied from class: `Tap`
      Returns `true` if there are properties in the nodeConfigDef instance.
      Specified by:
        `hasNodeConfigDef` in interface `ScopedElement`
      Overrides:
        `hasNodeConfigDef` in class `Tap<Config,Input,Output>`
      Returns:
        true if there are nodeConfigDef 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 `ScopedElement`
      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 stepConfigDef instance.
      Specified by:
        `hasStepConfigDef` in interface `ScopedElement`
      Overrides:
        `hasStepConfigDef` in class `Tap<Config,Input,Output>`
      Returns:
        true if there are stepConfigDef properties

    - #### toString

          public String toString()

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

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