Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.pentaho.di.trans
Class Trans

    java.lang.Object
      org.pentaho.di.trans.Trans

All Implemented Interfaces:
  org.pentaho.di.core.parameters.NamedParams, org.pentaho.di.core.variables.VariableSpace

    public class Trans

extends Object
implements org.pentaho.di.core.variables.VariableSpace, org.pentaho.di.core.parameters.NamedParams

This class is responsible for the execution of Transformations. It loads, instantiates, initializes, runs, monitors the execution of the transformation contained in the TransInfo object you feed it.

Since:
  07-04-2003
Author:
  Matt

Field Summary
`int` | `class_nr`
`static String` | `CONFIGURATION_IN_EXPORT_FILENAME`
`static String` | `REPLAY_DATE_FORMAT`
`static String` | `STRING_FINISHED`
`static String` | `STRING_HALTING`
`static String` | `STRING_INITIALIZING`
`static String` | `STRING_PREPARING`
`static String` | `STRING_RUNNING`
`static String` | `STRING_STOPPED`
`static String` | `STRING_WAITING`
`static int` | `TYPE_DISP_1_1`
`static int` | `TYPE_DISP_1_N`
`static int` | `TYPE_DISP_N_1`
`static int` | `TYPE_DISP_N_M`
`static int` | `TYPE_DISP_N_N`

Constructor Summary
`Trans(TransMeta transMeta)` Initialize a transformation from transformation meta-data defined in memory
`Trans(org.pentaho.di.core.variables.VariableSpace parentVariableSpace, Repository rep, String name, String dirname, String filename)`

Method Summary
`void` | `activateParameters()`
`void` | `addParameterDefinition(String key, String defValue, String description)`
`RowProducer` | `addRowProducer(String stepname, int copynr)` This adds a row producer to the transformation that just got set up.
`void` | `addTransListener(TransListener transListener)`
`void` | `beginProcessing()`
`void` | `cleanup()` Call this method after the transformation has finished.
`void` | `clearParameters()`
`void` | `copyParametersFrom(org.pentaho.di.core.parameters.NamedParams params)`
`void` | `copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)`
`boolean` | `endProcessing(String status)`
`String` | `environmentSubstitute(String aString)`
`String[]` | `environmentSubstitute(String[] aString)`
`void` | `eraseParameters()`
`void` | `execute(String[] arguments)` Execute this transformation.
`static TransSplitter` | `executeClustered(TransMeta transMeta, TransExecutionConfiguration executionConfiguration)`
`static void` | `executeClustered(TransSplitter transSplitter, TransExecutionConfiguration executionConfiguration)` executes an existing transSplitter, with transformation already split.
`List<BaseStep>` | `findBaseSteps(String stepname)`
`StepDataInterface` | `findDataInterface(String name)`
`MappingInput[]` | `findMappingInput()`
`MappingOutput[]` | `findMappingOutput()`
`org.pentaho.di.core.RowSet` | `findRowSet(String rowsetname)`
`org.pentaho.di.core.RowSet` | `findRowSet(String from, int fromcopy, String to, int tocopy)`
`BaseStep` | `findRunThread(String stepname)`
`long` | `getBatchId()`
`boolean` | `getBooleanValueOfVariable(String variableName, boolean defaultValue)`
`static org.pentaho.di.core.Result` | `getClusteredTransformationResult(String logSubject, TransSplitter transSplitter, Job parentJob)`
`Date` | `getCurrentDate()`
`Date` | `getDepDate()`
`Date` | `getEndDate()`
`int` | `getEnded()`
`int` | `getErrors()`
`Date` | `getJobEndDate()`
`Date` | `getJobStartDate()`
`long` | `getLastProcessed()`
`Date` | `getLogDate()`
`String` | `getMappingStepName()`
`String` | `getName()`
`String` | `getParameterDefault(String key)`
`String` | `getParameterDescription(String key)`
`String` | `getParameterValue(String key)`
`Job` | `getParentJob()`
`Trans` | `getParentTrans()`
`org.pentaho.di.core.variables.VariableSpace` | `getParentVariableSpace()`
`long` | `getPassedBatchId()`
`Date` | `getReplayDate()`
`Repository` | `getRepository()`
`org.pentaho.di.core.Result` | `getResult()`
`List<org.pentaho.di.core.RowSet>` | `getRowsets()`
`BaseStep` | `getRunThread(int i)`
`BaseStep` | `getRunThread(String name, int copy)`
`SocketRepository` | `getSocketRepository()`
`Date` | `getStartDate()`
`String` | `getStatus()`
`StepDataInterface` | `getStepDataInterface(String stepname, int stepcopy)` Finds the StepDataInterface (currently) associated with the specified step
`StepInterface` | `getStepInterface(String stepname, int copy)` Find the StepInterface (thread) by looking it up using the name
`Map<String,List<StepPerformanceSnapShot>>` | `getStepPerformanceSnapShots()`
`List<StepMetaDataCombi>` | `getSteps()`
`String` | `getThreadName()`
`List<TransListener>` | `getTransListeners()`
`TransMeta` | `getTransMeta()`
`String` | `getVariable(String variableName)`
`String` | `getVariable(String variableName, String defaultValue)`
`boolean` | `hasHaltedSteps()`
`boolean` | `hasStepStarted(String sname, int copy)`
`void` | `initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)`
`void` | `injectVariables(Map<String,String> prop)`
`boolean` | `isFinished()`
`boolean` | `isInitializing()`
`boolean` | `isMonitored()`
`boolean` | `isPaused()`
`boolean` | `isPreparing()`
`boolean` | `isPreview()`
`boolean` | `isReadyToStart()`
`boolean` | `isRunning()`
`boolean` | `isSafeModeEnabled()`
`boolean` | `isStopped()`
`void` | `killAll()`
`String[]` | `listParameters()`
`String[]` | `listVariables()`
`void` | `logSummary(StepInterface si)`
`static long` | `monitorClusteredTransformation(String logSubject, TransSplitter transSplitter, Job parentJob)` Consider that all the transformations in a cluster schema are running now... Now we should verify that they are all running as they should. If a transformation has an error, we should kill them all.. This should happen in a separate thread to prevent blocking of the UI. When the master and slave transformations have all finished, we should also run a cleanup on those transformations to release sockets, etc.
`static long` | `monitorClusteredTransformation(String logSubject, TransSplitter transSplitter, Job parentJob, int sleepTimeSeconds)` Consider that all the transformations in a cluster schema are running now... Now we should verify that they are all running as they should. If a transformation has an error, we should kill them all.. This should happen in a separate thread to prevent blocking of the UI. When the master and slave transformations have all finished, we should also run a cleanup on those transformations to release sockets, etc.
`static void` | `monitorRemoteTransformation(String transName, SlaveServer remoteSlaveServer)`
`static void` | `monitorRemoteTransformation(String transName, SlaveServer remoteSlaveServer, int sleepTimeSeconds)`
`int` | `nrActiveSteps()`
`int` | `nrSteps()`
`void` | `pauseRunning()` Pause the transformation (pause all steps)
`void` | `prepareExecution(String[] arguments)` Prepare the execution of the transformation.
`void` | `printStats(int seconds)`
`void` | `resumeRunning()` Resume running the transformation after a pause (resume all steps)
`static void` | `sendToSlaveServer(TransMeta transMeta, TransExecutionConfiguration executionConfiguration, Repository repository)`
`void` | `setBatchId(long batchId)`
`void` | `setInitializing(boolean initializing)`
`void` | `setInternalKettleVariables(org.pentaho.di.core.variables.VariableSpace var)`
`void` | `setJobEndDate(Date jobEndDate)`
`void` | `setJobStartDate(Date jobStartDate)`
`void` | `setMappingStepName(String mappingStepName)`
`void` | `setMonitored(boolean monitored)`
`void` | `setParameterValue(String key, String value)`
`void` | `setParentJob(Job parentJob)`
`void` | `setParentTrans(Trans parentTrans)`
`void` | `setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)`
`void` | `setPassedBatchId(long jobBatchId)`
`void` | `setPreparing(boolean preparing)`
`void` | `setPreview(boolean preview)`
`void` | `setReplayDate(Date replayDate)`
`void` | `setRepository(Repository repository)`
`void` | `setRunning(boolean running)`
`void` | `setSafeModeEnabled(boolean safeModeEnabled)` Turn on safe mode during running: the transformation will run slower but with more checking enabled.
`void` | `setSocketRepository(SocketRepository socketRepository)`
`void` | `setStepPerformanceSnapShots(Map<String,List<StepPerformanceSnapShot>> stepPerformanceSnapShots)`
`void` | `setThreadName(String threadName)`
`void` | `setTransListeners(List<TransListener> transListeners)`
`void` | `setTransMeta(TransMeta transMeta)`
`void` | `setVariable(String variableName, String variableValue)`
`void` | `shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)`
`void` | `startThreads()` Start the threads prepared by prepareThreads(); Before you start the threads, you can add RowListeners to them.
`void` | `stopAll()`
`String` | `toString()`
`void` | `waitUntilFinished()`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### REPLAY_DATE_FORMAT

    public static final String REPLAY_DATE_FORMAT

See Also:
  Constant Field Values

### class_nr

    public int class_nr

### TYPE_DISP_1_1

    public static final int TYPE_DISP_1_1

See Also:
  Constant Field Values

### TYPE_DISP_1_N

    public static final int TYPE_DISP_1_N

See Also:
  Constant Field Values

### TYPE_DISP_N_1

    public static final int TYPE_DISP_N_1

See Also:
  Constant Field Values

### TYPE_DISP_N_N

    public static final int TYPE_DISP_N_N

See Also:
  Constant Field Values

### TYPE_DISP_N_M

    public static final int TYPE_DISP_N_M

See Also:
  Constant Field Values

### STRING_FINISHED

    public static final String STRING_FINISHED

See Also:
  Constant Field Values

### STRING_RUNNING

    public static final String STRING_RUNNING

See Also:
  Constant Field Values

### STRING_PREPARING

    public static final String STRING_PREPARING

See Also:
  Constant Field Values

### STRING_INITIALIZING

    public static final String STRING_INITIALIZING

See Also:
  Constant Field Values

### STRING_WAITING

    public static final String STRING_WAITING

See Also:
  Constant Field Values

### STRING_STOPPED

    public static final String STRING_STOPPED

See Also:
  Constant Field Values

### STRING_HALTING

    public static final String STRING_HALTING

See Also:
  Constant Field Values

### CONFIGURATION_IN_EXPORT_FILENAME

    public static final String CONFIGURATION_IN_EXPORT_FILENAME

See Also:
  Constant Field Values

Constructor Detail

### Trans

    public Trans(TransMeta transMeta)

  Initialize a transformation from transformation meta-data defined in memory

  Parameters:
    `transMeta` - the transformation meta-data to use.

### Trans

    public Trans(org.pentaho.di.core.variables.VariableSpace parentVariableSpace,
                 Repository rep,
                 String name,
                 String dirname,
                 String filename)
          throws org.pentaho.di.core.exception.KettleException

Throws:
  `org.pentaho.di.core.exception.KettleException`

Method Detail

### getName

    public String getName()

### execute

    public void execute(String[] arguments)
                 throws org.pentaho.di.core.exception.KettleException

  Execute this transformation.

  Throws:
    `org.pentaho.di.core.exception.KettleException` - in case the transformation could not be prepared (initialized)

### prepareExecution

    public void prepareExecution(String[] arguments)
                          throws org.pentaho.di.core.exception.KettleException

  Prepare the execution of the transformation.

  Parameters:
    `arguments` - the arguments to use for this transformation
  Throws:
    `org.pentaho.di.core.exception.KettleException` - in case the transformation could not be prepared (initialized)

### startThreads

    public void startThreads()
                      throws org.pentaho.di.core.exception.KettleException

  Start the threads prepared by prepareThreads(); Before you start the threads, you can add RowListeners to them.

  Throws:
    `org.pentaho.di.core.exception.KettleException` - in case there is a communication error with a remote output socket.

### cleanup

    public void cleanup()

  Call this method after the transformation has finished. Typically, after ALL the slave transformations in a clustered run have finished.

### logSummary

    public void logSummary(StepInterface si)

### waitUntilFinished

    public void waitUntilFinished()

### getErrors

    public int getErrors()

### getEnded

    public int getEnded()

### isFinished

    public boolean isFinished()

### killAll

    public void killAll()

### printStats

    public void printStats(int seconds)

### getLastProcessed

    public long getLastProcessed()

### findRowSet

    public org.pentaho.di.core.RowSet findRowSet(String rowsetname)

### findRowSet

    public org.pentaho.di.core.RowSet findRowSet(String from,
                                                 int fromcopy,
                                                 String to,
                                                 int tocopy)

### hasStepStarted

    public boolean hasStepStarted(String sname,
                                  int copy)

### stopAll

    public void stopAll()

### nrSteps

    public int nrSteps()

### nrActiveSteps

    public int nrActiveSteps()

### getRunThread

    public BaseStep getRunThread(int i)

### getRunThread

    public BaseStep getRunThread(String name,
                                 int copy)

### beginProcessing

    public void beginProcessing()
                         throws org.pentaho.di.core.exception.KettleTransException

  Throws:
    `org.pentaho.di.core.exception.KettleTransException`

### getResult

    public org.pentaho.di.core.Result getResult()

### endProcessing

    public boolean endProcessing(String status)
                          throws org.pentaho.di.core.exception.KettleException

  Throws:
    `org.pentaho.di.core.exception.KettleException`

### findRunThread

    public BaseStep findRunThread(String stepname)

### findBaseSteps

    public List<BaseStep> findBaseSteps(String stepname)

### findDataInterface

    public StepDataInterface findDataInterface(String name)

### getStartDate

    public Date getStartDate()

  Returns:
    Returns the startDate.

### getEndDate

    public Date getEndDate()

  Returns:
    Returns the endDate.

### isMonitored

    public boolean isMonitored()

  Returns:
    See if the running transformation is monitored.

### setMonitored

    public void setMonitored(boolean monitored)

  Parameters:
    `monitored` - Indicate we want to monitor the running transformation

### getTransMeta

    public TransMeta getTransMeta()

  Returns:
    Returns the transMeta.

### setTransMeta

    public void setTransMeta(TransMeta transMeta)

  Parameters:
    `transMeta` - The transMeta to set.

### getCurrentDate

    public Date getCurrentDate()

  Returns:
    Returns the currentDate.

### getDepDate

    public Date getDepDate()

  Returns:
    Returns the depDate.

### getLogDate

    public Date getLogDate()

  Returns:
    Returns the logDate.

### getRowsets

    public List<org.pentaho.di.core.RowSet> getRowsets()

  Returns:
    Returns the rowsets.

### getSteps

    public List<StepMetaDataCombi> getSteps()

  Returns:
    Returns the steps.

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### findMappingInput

    public MappingInput[] findMappingInput()

### findMappingOutput

    public MappingOutput[] findMappingOutput()

### getStepInterface

    public StepInterface getStepInterface(String stepname,
                                          int copy)

  Find the StepInterface (thread) by looking it up using the name

  Parameters:
    `stepname` - The name of the step to look for
    `copy` - the copy number of the step to look for
  Returns:
    the StepInterface or null if nothing was found.

### getReplayDate

    public Date getReplayDate()

### setReplayDate

    public void setReplayDate(Date replayDate)

### setSafeModeEnabled

    public void setSafeModeEnabled(boolean safeModeEnabled)

  Turn on safe mode during running: the transformation will run slower but with more checking enabled.

  Parameters:
    `safeModeEnabled` - true for safe mode

### isSafeModeEnabled

    public boolean isSafeModeEnabled()

  Returns:
    Returns true if the safe mode is enabled: the transformation will run slower but with more checking enabled

### addRowProducer

    public RowProducer addRowProducer(String stepname,
                                      int copynr)
                               throws org.pentaho.di.core.exception.KettleException

  This adds a row producer to the transformation that just got set up. Preferable run this BEFORE execute() but after prepareExcution()

  Parameters:
    `stepname` - The step to produce rows for
    `copynr` - The copynr of the step to produce row for (normally 0 unless you have multiple copies running)
  Throws:
    `org.pentaho.di.core.exception.KettleException` - in case the thread/step to produce rows for could not be found.

### getParentJob

    public Job getParentJob()

  Returns:
    Returns the parentJob.

### setParentJob

    public void setParentJob(Job parentJob)

  Parameters:
    `parentJob` - The parentJob to set.

### getStepDataInterface

    public StepDataInterface getStepDataInterface(String stepname,
                                                  int stepcopy)

  Finds the StepDataInterface (currently) associated with the specified step

  Parameters:
    `stepname` - The name of the step to look for
    `stepcopy` - The copy number (0 based) of the step
  Returns:
    The StepDataInterface or null if non found.

### hasHaltedSteps

    public boolean hasHaltedSteps()

  Returns:
    true if one or more steps are halted

### getJobStartDate

    public Date getJobStartDate()

### getJobEndDate

    public Date getJobEndDate()

### setJobEndDate

    public void setJobEndDate(Date jobEndDate)

  Parameters:
    `jobEndDate` - the jobEndDate to set

### setJobStartDate

    public void setJobStartDate(Date jobStartDate)

  Parameters:
    `jobStartDate` - the jobStartDate to set

### getPassedBatchId

    public long getPassedBatchId()

  Returns:
    the jobBatchId

### setPassedBatchId

    public void setPassedBatchId(long jobBatchId)

  Parameters:
    `jobBatchId` - the jobBatchId to set

### getBatchId

    public long getBatchId()

  Returns:
    the batchId

### setBatchId

    public void setBatchId(long batchId)

  Parameters:
    `batchId` - the batchId to set

### getThreadName

    public String getThreadName()

  Returns:
    the threadName

### setThreadName

    public void setThreadName(String threadName)

  Parameters:
    `threadName` - the threadName to set

### getStatus

    public String getStatus()

### isInitializing

    public boolean isInitializing()

  Returns:
    the initializing

### setInitializing

    public void setInitializing(boolean initializing)

  Parameters:
    `initializing` - the initializing to set

### isPreparing

    public boolean isPreparing()

  Returns:
    the preparing

### setPreparing

    public void setPreparing(boolean preparing)

  Parameters:
    `preparing` - the preparing to set

### isRunning

    public boolean isRunning()

  Returns:
    the running

### setRunning

    public void setRunning(boolean running)

  Parameters:
    `running` - the running to set

### executeClustered

    public static final TransSplitter executeClustered(TransMeta transMeta,
                                                       TransExecutionConfiguration executionConfiguration)
                                                throws org.pentaho.di.core.exception.KettleException

  Throws:
    `org.pentaho.di.core.exception.KettleException`

### executeClustered

    public static final void executeClustered(TransSplitter transSplitter,
                                              TransExecutionConfiguration executionConfiguration)
                                       throws org.pentaho.di.core.exception.KettleException

  executes an existing transSplitter, with transformation already split. See also : org.pentaho.di.ui.spoon.delegates.SpoonTransformationDelegate

  Parameters:
    `transSplitter` -
    `executionConfiguration` -
  Throws:
    `org.pentaho.di.core.exception.KettleException`

### monitorClusteredTransformation

    public static final long monitorClusteredTransformation(String logSubject,
                                                            TransSplitter transSplitter,
                                                            Job parentJob)

  Consider that all the transformations in a cluster schema are running now...
  Now we should verify that they are all running as they should.
  If a transformation has an error, we should kill them all..
  This should happen in a separate thread to prevent blocking of the UI.
  When the master and slave transformations have all finished, we should also run
  a cleanup on those transformations to release sockets, etc.

  Parameters:
    `logSubject` - the subject to use for logging
    `transSplitter` - the transformation splitter object
    `parentJob` - the parent job when executed in a job, otherwise just set to null
    `sleepTimeSeconds` - the sleep time in seconds in between slave transformation status polling
  Returns:
    the number of errors encountered

### monitorClusteredTransformation

    public static final long monitorClusteredTransformation(String logSubject,
                                                            TransSplitter transSplitter,
                                                            Job parentJob,
                                                            int sleepTimeSeconds)

  Consider that all the transformations in a cluster schema are running now...
  Now we should verify that they are all running as they should.
  If a transformation has an error, we should kill them all..
  This should happen in a separate thread to prevent blocking of the UI.
  When the master and slave transformations have all finished, we should also run
  a cleanup on those transformations to release sockets, etc.

  Parameters:
    `logSubject` - the subject to use for logging
    `transSplitter` - the transformation splitter object
    `parentJob` - the parent job when executed in a job, otherwise just set to null
    `sleepTimeSeconds` - the sleep time in seconds in between slave transformation status polling
  Returns:
    the number of errors encountered

### getClusteredTransformationResult

    public static final org.pentaho.di.core.Result getClusteredTransformationResult(String logSubject,
                                                                                    TransSplitter transSplitter,
                                                                                    Job parentJob)

### sendToSlaveServer

    public static void sendToSlaveServer(TransMeta transMeta,
                                         TransExecutionConfiguration executionConfiguration,
                                         Repository repository)
                                  throws org.pentaho.di.core.exception.KettleException

  Throws:
    `org.pentaho.di.core.exception.KettleException`

### isReadyToStart

    public boolean isReadyToStart()

  Returns:
    true if the transformation was prepared for execution successfully.
  See Also:
    `prepareExecution(String[])`

### setInternalKettleVariables

    public void setInternalKettleVariables(org.pentaho.di.core.variables.VariableSpace var)

### copyVariablesFrom

    public void copyVariablesFrom(org.pentaho.di.core.variables.VariableSpace space)

  Specified by:
    `copyVariablesFrom` in interface `org.pentaho.di.core.variables.VariableSpace`

### environmentSubstitute

    public String environmentSubstitute(String aString)

  Specified by:
    `environmentSubstitute` in interface `org.pentaho.di.core.variables.VariableSpace`

### environmentSubstitute

    public String[] environmentSubstitute(String[] aString)

  Specified by:
    `environmentSubstitute` in interface `org.pentaho.di.core.variables.VariableSpace`

### getParentVariableSpace

    public org.pentaho.di.core.variables.VariableSpace getParentVariableSpace()

  Specified by:
    `getParentVariableSpace` in interface `org.pentaho.di.core.variables.VariableSpace`

### setParentVariableSpace

    public void setParentVariableSpace(org.pentaho.di.core.variables.VariableSpace parent)

  Specified by:
    `setParentVariableSpace` in interface `org.pentaho.di.core.variables.VariableSpace`

### getVariable

    public String getVariable(String variableName,
                              String defaultValue)

  Specified by:
    `getVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### getVariable

    public String getVariable(String variableName)

  Specified by:
    `getVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### getBooleanValueOfVariable

    public boolean getBooleanValueOfVariable(String variableName,
                                             boolean defaultValue)

  Specified by:
    `getBooleanValueOfVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### initializeVariablesFrom

    public void initializeVariablesFrom(org.pentaho.di.core.variables.VariableSpace parent)

  Specified by:
    `initializeVariablesFrom` in interface `org.pentaho.di.core.variables.VariableSpace`

### listVariables

    public String[] listVariables()

  Specified by:
    `listVariables` in interface `org.pentaho.di.core.variables.VariableSpace`

### setVariable

    public void setVariable(String variableName,
                            String variableValue)

  Specified by:
    `setVariable` in interface `org.pentaho.di.core.variables.VariableSpace`

### shareVariablesWith

    public void shareVariablesWith(org.pentaho.di.core.variables.VariableSpace space)

  Specified by:
    `shareVariablesWith` in interface `org.pentaho.di.core.variables.VariableSpace`

### injectVariables

    public void injectVariables(Map<String,String> prop)

  Specified by:
    `injectVariables` in interface `org.pentaho.di.core.variables.VariableSpace`

### pauseRunning

    public void pauseRunning()

  Pause the transformation (pause all steps)

### resumeRunning

    public void resumeRunning()

  Resume running the transformation after a pause (resume all steps)

### isPreview

    public boolean isPreview()

  Returns:
    the preview

### setPreview

    public void setPreview(boolean preview)

  Parameters:
    `preview` - the preview to set

### getRepository

    public Repository getRepository()

  Returns:
    the repository

### setRepository

    public void setRepository(Repository repository)

  Parameters:
    `repository` - the repository to set

### getStepPerformanceSnapShots

    public Map<String,List<StepPerformanceSnapShot>> getStepPerformanceSnapShots()

  Returns:
    the stepPerformanceSnapShots

### setStepPerformanceSnapShots

    public void setStepPerformanceSnapShots(Map<String,List<StepPerformanceSnapShot>> stepPerformanceSnapShots)

  Parameters:
    `stepPerformanceSnapShots` - the stepPerformanceSnapShots to set

### getTransListeners

    public List<TransListener> getTransListeners()

  Returns:
    the transListeners

### setTransListeners

    public void setTransListeners(List<TransListener> transListeners)

  Parameters:
    `transListeners` - the transListeners to set

### addTransListener

    public void addTransListener(TransListener transListener)

### isPaused

    public boolean isPaused()

### isStopped

    public boolean isStopped()

### monitorRemoteTransformation

    public static void monitorRemoteTransformation(String transName,
                                                   SlaveServer remoteSlaveServer)

### monitorRemoteTransformation

    public static void monitorRemoteTransformation(String transName,
                                                   SlaveServer remoteSlaveServer,
                                                   int sleepTimeSeconds)

### addParameterDefinition

    public void addParameterDefinition(String key,
                                       String defValue,
                                       String description)
                                throws org.pentaho.di.core.parameters.DuplicateParamException

  Specified by:
    `addParameterDefinition` in interface `org.pentaho.di.core.parameters.NamedParams`
  Throws:
    `org.pentaho.di.core.parameters.DuplicateParamException`

### getParameterDefault

    public String getParameterDefault(String key)
                               throws org.pentaho.di.core.parameters.UnknownParamException

  Specified by:
    `getParameterDefault` in interface `org.pentaho.di.core.parameters.NamedParams`
  Throws:
    `org.pentaho.di.core.parameters.UnknownParamException`

### getParameterDescription

    public String getParameterDescription(String key)
                                   throws org.pentaho.di.core.parameters.UnknownParamException

  Specified by:
    `getParameterDescription` in interface `org.pentaho.di.core.parameters.NamedParams`
  Throws:
    `org.pentaho.di.core.parameters.UnknownParamException`

### getParameterValue

    public String getParameterValue(String key)
                             throws org.pentaho.di.core.parameters.UnknownParamException

  Specified by:
    `getParameterValue` in interface `org.pentaho.di.core.parameters.NamedParams`
  Throws:
    `org.pentaho.di.core.parameters.UnknownParamException`

### listParameters

    public String[] listParameters()

  Specified by:
    `listParameters` in interface `org.pentaho.di.core.parameters.NamedParams`

### setParameterValue

    public void setParameterValue(String key,
                                  String value)
                           throws org.pentaho.di.core.parameters.UnknownParamException

  Specified by:
    `setParameterValue` in interface `org.pentaho.di.core.parameters.NamedParams`
  Throws:
    `org.pentaho.di.core.parameters.UnknownParamException`

### eraseParameters

    public void eraseParameters()

  Specified by:
    `eraseParameters` in interface `org.pentaho.di.core.parameters.NamedParams`

### clearParameters

    public void clearParameters()

  Specified by:
    `clearParameters` in interface `org.pentaho.di.core.parameters.NamedParams`

### activateParameters

    public void activateParameters()

  Specified by:
    `activateParameters` in interface `org.pentaho.di.core.parameters.NamedParams`

### copyParametersFrom

    public void copyParametersFrom(org.pentaho.di.core.parameters.NamedParams params)

  Specified by:
    `copyParametersFrom` in interface `org.pentaho.di.core.parameters.NamedParams`

### getParentTrans

    public Trans getParentTrans()

  Returns:
    the parentTrans

### setParentTrans

    public void setParentTrans(Trans parentTrans)

  Parameters:
    `parentTrans` - the parentTrans to set

### getMappingStepName

    public String getMappingStepName()

  Returns:
    the name of the mapping step that created this transformation

### setMappingStepName

    public void setMappingStepName(String mappingStepName)

  Parameters:
    `mappingStepName` - the name of the mapping step that created this transformation

### setSocketRepository

    public void setSocketRepository(SocketRepository socketRepository)

### getSocketRepository

    public SocketRepository getSocketRepository()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD