Package weka.knowledgeflow.steps

# Class Loader

java.lang.Object
weka.knowledgeflow.steps.BaseStep
weka.knowledgeflow.steps.WekaAlgorithmWrapper
weka.knowledgeflow.steps.Loader

All Implemented Interfaces:
  `Serializable`, `BaseStepExtender`, `Step`

@KFStep(name="Loader", category="DataSources", toolTipText="Weka loader wrapper", iconPath="") public class Loader extends WekaAlgorithmWrapper implements Serializable
Knowledge Flow step that wraps `weka.core.converters.Loader`s.

Version:
  $Revision: $
Author:
  Mark Hall (mhall{[at]}pentaho{[dot]}com)
See Also:
  - Serialized Form

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Loader()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `String`
  `getCustomEditorForStep()`
  Return the fully qualified name of a custom editor component (JComponent) to use for editing the properties of the step.
  `List<String>`
  `getIncomingConnectionTypes()`
  Get a list of incoming connection types that this step can accept.
  `Loader`
  `getLoader()`
  Convenience method - calls `getWrappedAlgorithm()`
  `List<String>`
  `getOutgoingConnectionTypes()`
  Get a list of outgoing connection types that this step can produce.
  `Class`
  `getWrappedAlgorithmClass()`
  Get the class of the wrapped algorithm
  `Instances`
  `outputStructureForConnectionType(String connectionName, Environment env)`
  If possible, get the output structure for the named connection type as a header-only set of instances.
  `void`
  `setLoader(Loader loader)`
  Convenience method - calls `setWrappedAlgorithm()`
  `void`
  `setWrappedAlgorithm(Object algo)`
  Set the wrapped algorithm to use
  `void`
  `start()`
  Start executing
  `void`
  `stepInit()`
  Initialize the step.

  ### Methods inherited from class weka.knowledgeflow.steps.WekaAlgorithmWrapper

  `getDefaultIconPath, getDefaultPackageLevelIconPath, getIconPath, getWrappedAlgorithm, globalInfo`

  ### Methods inherited from class weka.knowledgeflow.steps.BaseStep

  `environmentSubstitute, getDefaultSettings, getInteractiveViewers, getInteractiveViewersImpls, getName, getStepManager, isResourceIntensive, isStopRequested, outputStructureForConnectionType, processIncoming, setName, setStepIsResourceIntensive, setStepManager, setStepMustRunSingleThreaded, stepMustRunSingleThreaded, stop`

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

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

- ## Constructor Details

  - ### Loader

    public Loader()

- ## Method Details

  - ### getWrappedAlgorithmClass

    public Class getWrappedAlgorithmClass()
    Get the class of the wrapped algorithm
    Specified by:
      `getWrappedAlgorithmClass` in class `WekaAlgorithmWrapper`
    Returns:
      the class of the wrapped algorithm

  - ### setWrappedAlgorithm

    public void setWrappedAlgorithm(Object algo)
    Set the wrapped algorithm to use
    Overrides:
      `setWrappedAlgorithm` in class `WekaAlgorithmWrapper`
    Parameters:
      `algo` - the algorithm to use

  - ### getLoader

    public Loader getLoader()
    Convenience method - calls `getWrappedAlgorithm()`
    Returns:
      the wrapped loader

  - ### setLoader

    @ProgrammaticProperty public void setLoader(Loader loader)
    Convenience method - calls `setWrappedAlgorithm()`
    Parameters:
      `loader` - the loader to use

  - ### stepInit

    public void stepInit() throws WekaException
    Initialize the step.
    Specified by:
      `stepInit` in interface `BaseStepExtender`
    Specified by:
      `stepInit` in interface `Step`
    Throws:
      `WekaException` - if a problem occurs during initialization

  - ### start

    public void start() throws WekaException
    Start executing
    Specified by:
      `start` in interface `BaseStepExtender`
    Specified by:
      `start` in interface `Step`
    Overrides:
      `start` in class `BaseStep`
    Throws:
      `WekaException` - if a problem occurs

  - ### outputStructureForConnectionType

    public Instances outputStructureForConnectionType(String connectionName, Environment env) throws WekaException
    If possible, get the output structure for the named connection type as a header-only set of instances. Can return null if the specified connection type is not representable as Instances or cannot be determined at present.
    Specified by:
      `outputStructureForConnectionType` in interface `Step`
    Overrides:
      `outputStructureForConnectionType` in class `BaseStep`
    Parameters:
      `connectionName` - the name of the connection type to get the output structure for
      `env` - Environment to use
    Returns:
      the output structure as a header-only Instances object
    Throws:
      `WekaException` - if a problem occurs

  - ### getIncomingConnectionTypes

    public List<String> getIncomingConnectionTypes()
    Get a list of incoming connection types that this step can accept. Ideally (and if appropriate), this should take into account the state of the step and any existing incoming connections. E.g. a step might be able to accept one (and only one) incoming batch data connection.
    Specified by:
      `getIncomingConnectionTypes` in interface `BaseStepExtender`
    Specified by:
      `getIncomingConnectionTypes` in interface `Step`
    Returns:
      a list of incoming connections that this step can accept given its current state

  - ### getOutgoingConnectionTypes

    public List<String> getOutgoingConnectionTypes()
    Get a list of outgoing connection types that this step can produce. Ideally (and if appropriate), this should take into account the state of the step and the incoming connections. E.g. depending on what incoming connection is present, a step might be able to produce a trainingSet output, a testSet output or neither, but not both.
    Specified by:
      `getOutgoingConnectionTypes` in interface `BaseStepExtender`
    Specified by:
      `getOutgoingConnectionTypes` in interface `Step`
    Returns:
      a list of outgoing connections that this step can produce

  - ### getCustomEditorForStep

    public String getCustomEditorForStep()
    Return the fully qualified name of a custom editor component (JComponent) to use for editing the properties of the step. This method can return null, in which case the system will dynamically generate an editor using the GenericObjectEditor
    Specified by:
      `getCustomEditorForStep` in interface `Step`
    Overrides:
      `getCustomEditorForStep` in class `BaseStep`
    Returns:
      the fully qualified name of a step editor component