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.steps.textfileinput
Class TextFileInputMeta

    java.lang.Object
      org.pentaho.di.trans.step.BaseStepMeta
          org.pentaho.di.trans.steps.textfileinput.TextFileInputMeta

All Implemented Interfaces:
  Cloneable, StepMetaInterface, InputFileMetaInterface

    public class TextFileInputMeta

extends BaseStepMeta
implements StepMetaInterface, InputFileMetaInterface

Field Summary
`static int` | `FILE_FORMAT_DOS`
`static int` | `FILE_FORMAT_MIXED`
`static int` | `FILE_FORMAT_UNIX`
`static int` | `FILE_TYPE_CSV`
`static int` | `FILE_TYPE_FIXED`

Constructor Summary
`TextFileInputMeta()`

Method Summary
`void` | `allocate(int nrfiles, int nrfields, int nrfilters)`
`void` | `check(List<org.pentaho.di.core.CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepinfo, org.pentaho.di.core.row.RowMetaInterface prev, String[] input, String[] output, org.pentaho.di.core.row.RowMetaInterface info)` Checks the settings of this step and puts the findings in a remarks List.
`Object` | `clone()` Make an exact copy of this step, make sure to explicitly copy Collections etc.
`String` | `exportResources(org.pentaho.di.core.variables.VariableSpace space, Map<String,ResourceDefinition> definitions, ResourceNamingInterface resourceNamingInterface, Repository repository)` Since the exported transformation that runs this will reside in a ZIP file, we can't reference files relatively.
`String` | `getAcceptingField()`
`StepMeta` | `getAcceptingStep()`
`String` | `getAcceptingStepName()`
`Locale` | `getDateFormatLocale()`
`String` | `getEnclosure()`
`String` | `getEncoding()`
`String` | `getErrorCountField()`
`String` | `getErrorFieldsField()`
`String` | `getErrorFilesDestinationDirectory()`
`String` | `getErrorLineFilesExtension()`
`String` | `getErrorTextField()`
`String` | `getEscapeCharacter()`
`void` | `getFields(org.pentaho.di.core.row.RowMetaInterface row, String name, org.pentaho.di.core.row.RowMetaInterface[] info, StepMeta nextStep, org.pentaho.di.core.variables.VariableSpace space)` Get the fields that are emitted by this step
`String` | `getFileCompression()`
`String` | `getFileFormat()`
`int` | `getFileFormatTypeNr()`
`String[]` | `getFileMask()`
`String[]` | `getFileName()`
`String` | `getFilenameField()`
`String[]` | `getFilePaths(org.pentaho.di.core.variables.VariableSpace space)`
`String[]` | `getFileRequired()`
`String` | `getFileType()`
`int` | `getFileTypeNr()`
`TextFileFilter[]` | `getFilter()`
`String[]` | `getInfoSteps()`
`TextFileInputField[]` | `getInputFields()`
`String` | `getLineNumberFilesDestinationDirectory()`
`String` | `getLineNumberFilesExtension()`
`String` | `getLookupStepname()`
`int` | `getNrFooterLines()`
`int` | `getNrHeaderLines()`
`int` | `getNrLinesDocHeader()`
`int` | `getNrLinesPerPage()`
`int` | `getNrWraps()`
`List<ResourceReference>` | `getResourceDependencies(TransMeta transMeta, StepMeta stepInfo)` Get a list of all the resource dependencies that the step is depending on.
`long` | `getRowLimit()`
`String` | `getRowNumberField()`
`String` | `getSeparator()`
`StepInterface` | `getStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta transMeta, Trans trans)` Get the executing step, needed by Trans to launch a step.
`StepDataInterface` | `getStepData()` Get a new instance of the appropriate data class.
`org.pentaho.di.core.fileinput.FileInputList` | `getTextFileList(org.pentaho.di.core.variables.VariableSpace space)`
`String` | `getWarningFilesDestinationDirectory()`
`String` | `getWarningFilesExtension()`
`String` | `getXML()` Produces the XML string that describes this step's information.
`boolean` | `hasFooter()`
`boolean` | `hasHeader()`
`boolean` | `includeFilename()`
`boolean` | `includeRowNumber()`
`boolean` | `isAcceptingFilenames()`
`boolean` | `isAddResultFile()`
`boolean` | `isBreakInEnclosureAllowed()`
`boolean` | `isDateFormatLenient()`
`boolean` | `isErrorIgnored()`
`boolean` | `isErrorLineSkipped()`
`boolean` | `isLayoutPaged()`
`boolean` | `isLineWrapped()`
`boolean` | `isPassingThruFields()`
`boolean` | `isRowNumberByFile()` true if row number reset for each file
`void` | `loadXML(Node stepnode, List<org.pentaho.di.core.database.DatabaseMeta> databases, Map<String,org.pentaho.di.core.Counter> counters)` Load the values for this step from an XML Node
`boolean` | `noEmptyLines()`
`void` | `readRep(Repository rep, long id_step, List<org.pentaho.di.core.database.DatabaseMeta> databases, Map<String,org.pentaho.di.core.Counter> counters)` Read the steps information from a Kettle repository
`void` | `saveRep(Repository rep, long id_transformation, long id_step)` Save the steps data into a Kettle repository
`void` | `searchInfoAndTargetSteps(List<StepMeta> steps)`
`void` | `setAcceptingField(String fileNameField)`
`void` | `setAcceptingFilenames(boolean getFileFromJob)`
`void` | `setAcceptingStep(StepMeta acceptingStep)`
`void` | `setAcceptingStepName(String acceptingStep)`
`void` | `setAddResultFile(boolean isaddresult)`
`void` | `setBreakInEnclosureAllowed(boolean breakInEnclosureAllowed)`
`void` | `setDateFormatLenient(boolean dateFormatLenient)`
`void` | `setDateFormatLocale(Locale dateFormatLocale)`
`void` | `setDefault()` Set default values
`void` | `setEnclosure(String enclosure)`
`void` | `setEncoding(String encoding)`
`void` | `setErrorCountField(String errorCountField)`
`void` | `setErrorFieldsField(String errorFieldsField)`
`void` | `setErrorFilesDestinationDirectory(String errorFilesDestinationDirectory)`
`void` | `setErrorIgnored(boolean errorIgnored)`
`void` | `setErrorLineFilesExtension(String errorLineFilesExtension)`
`void` | `setErrorLineSkipped(boolean errorLineSkipped)`
`void` | `setErrorTextField(String errorTextField)`
`void` | `setEscapeCharacter(String escapeCharacter)`
`void` | `setFileCompression(String fileCompression)`
`void` | `setFileFormat(String fileFormat)`
`void` | `setFileMask(String[] fileMask)`
`void` | `setFileName(String[] fileName)`
`void` | `setFilenameField(String filenameField)`
`void` | `setFileRequired(String[] fileRequired)`
`void` | `setFileType(String fileType)`
`void` | `setFilter(TextFileFilter[] filter)`
`void` | `setFooter(boolean footer)`
`void` | `setHeader(boolean header)`
`void` | `setIncludeFilename(boolean includeFilename)`
`void` | `setIncludeRowNumber(boolean includeRowNumber)`
`void` | `setInputFields(TextFileInputField[] inputFields)`
`void` | `setLayoutPaged(boolean layoutPaged)`
`void` | `setLineNumberFilesDestinationDirectory(String lineNumberFilesDestinationDirectory)`
`void` | `setLineNumberFilesExtension(String lineNumberFilesExtension)`
`void` | `setLineWrapped(boolean lineWrapped)`
`void` | `setNoEmptyLines(boolean noEmptyLines)`
`void` | `setNrFooterLines(int nrFooterLines)`
`void` | `setNrHeaderLines(int nrHeaderLines)`
`void` | `setNrLinesDocHeader(int nrLinesDocHeader)`
`void` | `setNrLinesPerPage(int nrLinesPerPage)`
`void` | `setNrWraps(int nrWraps)`
`void` | `setPassingThruFields(boolean passingThruFields)`
`void` | `setRowLimit(long rowLimit)`
`void` | `setRowNumberByFile(boolean rowNumberByFile)`
`void` | `setRowNumberField(String rowNumberField)`
`void` | `setSeparator(String separator)`
`void` | `setWarningFilesDestinationDirectory(String warningFilesDestinationDirectory)`
`void` | `setWarningFilesExtension(String warningFilesExtension)`

Methods inherited from class org.pentaho.di.trans.step.BaseStepMeta
`analyseImpact, cancelQueries, chosesTargetSteps, excludeFromRowLayoutVerification, getDialogClassName, getID, getRequiredFields, getRequiredFields, getSQLStatements, getTableFields, getTargetSteps, getUsedArguments, getUsedDatabaseConnections, getUsedLibraries, hasChanged, setChanged, setChanged, setID, setInfoSteps, setTargetSteps, supportsErrorHandling`

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

Field Detail

### FILE_FORMAT_DOS

    public static final int FILE_FORMAT_DOS

See Also:
  Constant Field Values

### FILE_FORMAT_UNIX

    public static final int FILE_FORMAT_UNIX

See Also:
  Constant Field Values

### FILE_FORMAT_MIXED

    public static final int FILE_FORMAT_MIXED

See Also:
  Constant Field Values

### FILE_TYPE_CSV

    public static final int FILE_TYPE_CSV

See Also:
  Constant Field Values

### FILE_TYPE_FIXED

    public static final int FILE_TYPE_FIXED

See Also:
  Constant Field Values

Constructor Detail

### TextFileInputMeta

    public TextFileInputMeta()

Method Detail

### getEncoding

    public String getEncoding()

  Returns:
    Returns the encoding.

### setEncoding

    public void setEncoding(String encoding)

  Parameters:
    `encoding` - The encoding to set.

### getInputFields

    public TextFileInputField[] getInputFields()

  Specified by:
    `getInputFields` in interface `InputFileMetaInterface`
  Returns:
    Returns the input fields.

### setInputFields

    public void setInputFields(TextFileInputField[] inputFields)

  Parameters:
    `inputFields` - The input fields to set.

### getEnclosure

    public String getEnclosure()

  Specified by:
    `getEnclosure` in interface `InputFileMetaInterface`
  Returns:
    Returns the enclosure.

### setEnclosure

    public void setEnclosure(String enclosure)

  Parameters:
    `enclosure` - The enclosure to set.

### isBreakInEnclosureAllowed

    public boolean isBreakInEnclosureAllowed()

  Returns:
    Returns the breakInEnclosureAllowed.

### setBreakInEnclosureAllowed

    public void setBreakInEnclosureAllowed(boolean breakInEnclosureAllowed)

  Parameters:
    `breakInEnclosureAllowed` - The breakInEnclosureAllowed to set.

### getFileFormat

    public String getFileFormat()

  Returns:
    Returns the fileFormat.

### setFileFormat

    public void setFileFormat(String fileFormat)

  Parameters:
    `fileFormat` - The fileFormat to set.

### getFileMask

    public String[] getFileMask()

  Returns:
    Returns the fileMask.

### getFileRequired

    public String[] getFileRequired()

  Returns:
    Returns the fileRequired.

### setFileMask

    public void setFileMask(String[] fileMask)

  Parameters:
    `fileMask` - The fileMask to set.

### setFileRequired

    public void setFileRequired(String[] fileRequired)

  Parameters:
    `fileRequired` - The fileRequired to set.

### getFileName

    public String[] getFileName()

  Returns:
    Returns the fileName.

### setFileName

    public void setFileName(String[] fileName)

  Parameters:
    `fileName` - The fileName to set.

### getFilenameField

    public String getFilenameField()

  Returns:
    Returns the filenameField.

### setFilenameField

    public void setFilenameField(String filenameField)

  Parameters:
    `filenameField` - The filenameField to set.

### getFileType

    public String getFileType()

  Specified by:
    `getFileType` in interface `InputFileMetaInterface`
  Returns:
    Returns the fileType.

### setFileType

    public void setFileType(String fileType)

  Parameters:
    `fileType` - The fileType to set.

### getFilter

    public TextFileFilter[] getFilter()

  Returns:
    The array of filters for the metadata of this text file input step.

### setFilter

    public void setFilter(TextFileFilter[] filter)

  Parameters:
    `filter` - The array of filters to use

### hasFooter

    public boolean hasFooter()

  Returns:
    Returns the footer.

### setFooter

    public void setFooter(boolean footer)

  Parameters:
    `footer` - The footer to set.

### hasHeader

    public boolean hasHeader()

  Specified by:
    `hasHeader` in interface `InputFileMetaInterface`
  Returns:
    Returns the header.

### setHeader

    public void setHeader(boolean header)

  Parameters:
    `header` - The header to set.

### includeFilename

    public boolean includeFilename()

  Specified by:
    `includeFilename` in interface `InputFileMetaInterface`
  Returns:
    Returns the includeFilename.

### setIncludeFilename

    public void setIncludeFilename(boolean includeFilename)

  Parameters:
    `includeFilename` - The includeFilename to set.

### includeRowNumber

    public boolean includeRowNumber()

  Specified by:
    `includeRowNumber` in interface `InputFileMetaInterface`
  Returns:
    Returns the includeRowNumber.

### setIncludeRowNumber

    public void setIncludeRowNumber(boolean includeRowNumber)

  Parameters:
    `includeRowNumber` - The includeRowNumber to set.

### isRowNumberByFile

    public boolean isRowNumberByFile()

  true if row number reset for each file

  Returns:
    rowNumberByFile

### setRowNumberByFile

    public void setRowNumberByFile(boolean rowNumberByFile)

  Parameters:
    `rowNumberByFile` - True if row number field is reset for each file

### noEmptyLines

    public boolean noEmptyLines()

  Returns:
    Returns the noEmptyLines.

### setNoEmptyLines

    public void setNoEmptyLines(boolean noEmptyLines)

  Parameters:
    `noEmptyLines` - The noEmptyLines to set.

### getRowLimit

    public long getRowLimit()

  Returns:
    Returns the rowLimit.

### setRowLimit

    public void setRowLimit(long rowLimit)

  Parameters:
    `rowLimit` - The rowLimit to set.

### getRowNumberField

    public String getRowNumberField()

  Returns:
    Returns the rowNumberField.

### setRowNumberField

    public void setRowNumberField(String rowNumberField)

  Parameters:
    `rowNumberField` - The rowNumberField to set.

### getSeparator

    public String getSeparator()

  Specified by:
    `getSeparator` in interface `InputFileMetaInterface`
  Returns:
    Returns the separator.

### setSeparator

    public void setSeparator(String separator)

  Parameters:
    `separator` - The separator to set.

### getFileCompression

    public String getFileCompression()

  Returns:
    Returns the type of compression used

### setFileCompression

    public void setFileCompression(String fileCompression)

  Parameters:
    `fileCompression` - Sets the compression type

### loadXML

    public void loadXML(Node stepnode,
                        List<org.pentaho.di.core.database.DatabaseMeta> databases,
                        Map<String,org.pentaho.di.core.Counter> counters)
                 throws org.pentaho.di.core.exception.KettleXMLException

  Description copied from interface: `StepMetaInterface`
  Load the values for this step from an XML Node

  Specified by:
    `loadXML` in interface `StepMetaInterface`
  Parameters:
    `stepnode` - the Node to get the info from
    `databases` - The available list of databases to reference to
    `counters` - Counters to reference.
  Throws:
    `org.pentaho.di.core.exception.KettleXMLException` - When an unexpected XML error occurred. (malformed etc.)

### clone

    public Object clone()

  Description copied from interface: `StepMetaInterface`
  Make an exact copy of this step, make sure to explicitly copy Collections etc.

  Specified by:
    `clone` in interface `StepMetaInterface`
  Overrides:
    `clone` in class `BaseStepMeta`
  Returns:
    an exact copy of this step

### allocate

    public void allocate(int nrfiles,
                         int nrfields,
                         int nrfilters)

### setDefault

    public void setDefault()

  Description copied from interface: `StepMetaInterface`
  Set default values

  Specified by:
    `setDefault` in interface `StepMetaInterface`

### getFields

    public void getFields(org.pentaho.di.core.row.RowMetaInterface row,
                          String name,
                          org.pentaho.di.core.row.RowMetaInterface[] info,
                          StepMeta nextStep,
                          org.pentaho.di.core.variables.VariableSpace space)
                   throws org.pentaho.di.core.exception.KettleStepException

  Description copied from interface: `StepMetaInterface`
  Get the fields that are emitted by this step

  Specified by:
    `getFields` in interface `StepMetaInterface`
  Overrides:
    `getFields` in class `BaseStepMeta`
  Parameters:
    `row` - The fields that are entering the step. These are changed to reflect the output metadata.
    `name` - The name of the step to be used as origin
    `info` - The input rows metadata that enters the step through the specified channels in the same order as in method getInfoSteps(). The step metadata can then choose what to do with it: ignore it or not. Interesting is also that in case of database lookups, the layout of the target database table is put in info[0]
    `nextStep` - if this is a non-null value, it's the next step in the transformation. The one who's asking, the step where the data is targetted towards.
    `space` - TODO
  Throws:
    `org.pentaho.di.core.exception.KettleStepException` - when an error occurred searching for the fields.

### getXML

    public String getXML()

  Description copied from class: `BaseStepMeta`
  Produces the XML string that describes this step's information.

  Specified by:
    `getXML` in interface `StepMetaInterface`
  Overrides:
    `getXML` in class `BaseStepMeta`
  Returns:
    String containing the XML describing this step.

### getLookupStepname

    public String getLookupStepname()

### searchInfoAndTargetSteps

    public void searchInfoAndTargetSteps(List<StepMeta> steps)

  Specified by:
    `searchInfoAndTargetSteps` in interface `StepMetaInterface`
  Overrides:
    `searchInfoAndTargetSteps` in class `BaseStepMeta`
  Parameters:
    `steps` - optionally search the info step in a list of steps

### getInfoSteps

    public String[] getInfoSteps()

  Specified by:
    `getInfoSteps` in interface `StepMetaInterface`
  Overrides:
    `getInfoSteps` in class `BaseStepMeta`
  Returns:
    the informational source steps, if any. Null is the default: none.

### readRep

    public void readRep(Repository rep,
                        long id_step,
                        List<org.pentaho.di.core.database.DatabaseMeta> databases,
                        Map<String,org.pentaho.di.core.Counter> counters)
                 throws org.pentaho.di.core.exception.KettleException

  Description copied from interface: `StepMetaInterface`
  Read the steps information from a Kettle repository

  Specified by:
    `readRep` in interface `StepMetaInterface`
  Parameters:
    `rep` - The repository to read from
    `id_step` - The step ID
    `databases` - The databases to reference
    `counters` - The counters to reference
  Throws:
    `org.pentaho.di.core.exception.KettleException` - When an unexpected error occurred (database, network, etc)

### saveRep

    public void saveRep(Repository rep,
                        long id_transformation,
                        long id_step)
                 throws org.pentaho.di.core.exception.KettleException

  Description copied from interface: `StepMetaInterface`
  Save the steps data into a Kettle repository

  Specified by:
    `saveRep` in interface `StepMetaInterface`
  Parameters:
    `rep` - The Kettle repository to save to
    `id_transformation` - The transformation ID
    `id_step` - The step ID
  Throws:
    `org.pentaho.di.core.exception.KettleException` - When an unexpected error occurred (database, network, etc)

### getFilePaths

    public String[] getFilePaths(org.pentaho.di.core.variables.VariableSpace space)

  Specified by:
    `getFilePaths` in interface `InputFileMetaInterface`

### getTextFileList

    public org.pentaho.di.core.fileinput.FileInputList getTextFileList(org.pentaho.di.core.variables.VariableSpace space)

### check

    public void check(List<org.pentaho.di.core.CheckResultInterface> remarks,
                      TransMeta transMeta,
                      StepMeta stepinfo,
                      org.pentaho.di.core.row.RowMetaInterface prev,
                      String[] input,
                      String[] output,
                      org.pentaho.di.core.row.RowMetaInterface info)

  Description copied from interface: `StepMetaInterface`
  Checks the settings of this step and puts the findings in a remarks List.

  Specified by:
    `check` in interface `StepMetaInterface`
  Parameters:
    `remarks` - The list to put the remarks in @see org.pentaho.di.core.CheckResult
    `stepinfo` - The stepMeta to help checking
    `prev` - The fields coming from the previous step
    `input` - The input step names
    `output` - The output step names
    `info` - The fields that are used as information by the step

### getStep

    public StepInterface getStep(StepMeta stepMeta,
                                 StepDataInterface stepDataInterface,
                                 int cnr,
                                 TransMeta transMeta,
                                 Trans trans)

  Description copied from interface: `StepMetaInterface`
  Get the executing step, needed by Trans to launch a step.

  Specified by:
    `getStep` in interface `StepMetaInterface`
  Parameters:
    `stepMeta` - The step info
    `stepDataInterface` - the step data interface linked to this step. Here the step can store temporary data, database connections, etc.
    `cnr` - The copy nr to get
    `transMeta` - The transformation info
    `trans` - The launching transformation

### getStepData

    public StepDataInterface getStepData()

  Description copied from interface: `StepMetaInterface`
  Get a new instance of the appropriate data class. This data class implements the StepDataInterface. It basically contains the persisting data that needs to live on, even if a worker thread is terminated.

  Specified by:
    `getStepData` in interface `StepMetaInterface`
  Returns:
    The appropriate StepDataInterface class.

### getEscapeCharacter

    public String getEscapeCharacter()

  Specified by:
    `getEscapeCharacter` in interface `InputFileMetaInterface`
  Returns:
    Returns the escapeCharacter.

### setEscapeCharacter

    public void setEscapeCharacter(String escapeCharacter)

  Parameters:
    `escapeCharacter` - The escapeCharacter to set.

### getErrorCountField

    public String getErrorCountField()

  Specified by:
    `getErrorCountField` in interface `InputFileMetaInterface`

### setErrorCountField

    public void setErrorCountField(String errorCountField)

### getErrorFieldsField

    public String getErrorFieldsField()

  Specified by:
    `getErrorFieldsField` in interface `InputFileMetaInterface`

### setErrorFieldsField

    public void setErrorFieldsField(String errorFieldsField)

### isErrorIgnored

    public boolean isErrorIgnored()

  Specified by:
    `isErrorIgnored` in interface `InputFileMetaInterface`

### setErrorIgnored

    public void setErrorIgnored(boolean errorIgnored)

### getErrorTextField

    public String getErrorTextField()

  Specified by:
    `getErrorTextField` in interface `InputFileMetaInterface`

### setErrorTextField

    public void setErrorTextField(String errorTextField)

### isLineWrapped

    public boolean isLineWrapped()

  Returns:
    Returns the lineWrapped.

### setLineWrapped

    public void setLineWrapped(boolean lineWrapped)

  Parameters:
    `lineWrapped` - The lineWrapped to set.

### getNrFooterLines

    public int getNrFooterLines()

  Returns:
    Returns the nrFooterLines.

### setNrFooterLines

    public void setNrFooterLines(int nrFooterLines)

  Parameters:
    `nrFooterLines` - The nrFooterLines to set.

### getNrHeaderLines

    public int getNrHeaderLines()

  Specified by:
    `getNrHeaderLines` in interface `InputFileMetaInterface`
  Returns:
    Returns the nrHeaderLines.

### setNrHeaderLines

    public void setNrHeaderLines(int nrHeaderLines)

  Parameters:
    `nrHeaderLines` - The nrHeaderLines to set.

### getNrWraps

    public int getNrWraps()

  Returns:
    Returns the nrWraps.

### setNrWraps

    public void setNrWraps(int nrWraps)

  Parameters:
    `nrWraps` - The nrWraps to set.

### isLayoutPaged

    public boolean isLayoutPaged()

  Returns:
    Returns the layoutPaged.

### setLayoutPaged

    public void setLayoutPaged(boolean layoutPaged)

  Parameters:
    `layoutPaged` - The layoutPaged to set.

### getNrLinesPerPage

    public int getNrLinesPerPage()

  Returns:
    Returns the nrLinesPerPage.

### setNrLinesPerPage

    public void setNrLinesPerPage(int nrLinesPerPage)

  Parameters:
    `nrLinesPerPage` - The nrLinesPerPage to set.

### getNrLinesDocHeader

    public int getNrLinesDocHeader()

  Returns:
    Returns the nrLinesDocHeader.

### setNrLinesDocHeader

    public void setNrLinesDocHeader(int nrLinesDocHeader)

  Parameters:
    `nrLinesDocHeader` - The nrLinesDocHeader to set.

### getWarningFilesDestinationDirectory

    public String getWarningFilesDestinationDirectory()

### setWarningFilesDestinationDirectory

    public void setWarningFilesDestinationDirectory(String warningFilesDestinationDirectory)

### getWarningFilesExtension

    public String getWarningFilesExtension()

### setWarningFilesExtension

    public void setWarningFilesExtension(String warningFilesExtension)

### getLineNumberFilesDestinationDirectory

    public String getLineNumberFilesDestinationDirectory()

### setLineNumberFilesDestinationDirectory

    public void setLineNumberFilesDestinationDirectory(String lineNumberFilesDestinationDirectory)

### getLineNumberFilesExtension

    public String getLineNumberFilesExtension()

### setLineNumberFilesExtension

    public void setLineNumberFilesExtension(String lineNumberFilesExtension)

### getErrorFilesDestinationDirectory

    public String getErrorFilesDestinationDirectory()

### setErrorFilesDestinationDirectory

    public void setErrorFilesDestinationDirectory(String errorFilesDestinationDirectory)

### getErrorLineFilesExtension

    public String getErrorLineFilesExtension()

### setErrorLineFilesExtension

    public void setErrorLineFilesExtension(String errorLineFilesExtension)

### isDateFormatLenient

    public boolean isDateFormatLenient()

### setDateFormatLenient

    public void setDateFormatLenient(boolean dateFormatLenient)

### setAddResultFile

    public void setAddResultFile(boolean isaddresult)

  Parameters:
    `isaddresult` - The isaddresult to set.

### isAddResultFile

    public boolean isAddResultFile()

  Returns:
    Returns isaddresult.

### isErrorLineSkipped

    public boolean isErrorLineSkipped()

  Specified by:
    `isErrorLineSkipped` in interface `InputFileMetaInterface`

### setErrorLineSkipped

    public void setErrorLineSkipped(boolean errorLineSkipped)

### getDateFormatLocale

    public Locale getDateFormatLocale()

  Returns:
    Returns the dateFormatLocale.

### setDateFormatLocale

    public void setDateFormatLocale(Locale dateFormatLocale)

  Parameters:
    `dateFormatLocale` - The dateFormatLocale to set.

### isAcceptingFilenames

    public boolean isAcceptingFilenames()

### setAcceptingFilenames

    public void setAcceptingFilenames(boolean getFileFromJob)

### isPassingThruFields

    public boolean isPassingThruFields()

### setPassingThruFields

    public void setPassingThruFields(boolean passingThruFields)

### getAcceptingField

    public String getAcceptingField()

  Returns:
    Returns the fileNameField.

### setAcceptingField

    public void setAcceptingField(String fileNameField)

  Parameters:
    `fileNameField` - The fileNameField to set.

### getAcceptingStepName

    public String getAcceptingStepName()

  Returns:
    Returns the acceptingStep.

### setAcceptingStepName

    public void setAcceptingStepName(String acceptingStep)

  Parameters:
    `acceptingStep` - The acceptingStep to set.

### getAcceptingStep

    public StepMeta getAcceptingStep()

  Returns:
    Returns the acceptingStep.

### setAcceptingStep

    public void setAcceptingStep(StepMeta acceptingStep)

  Parameters:
    `acceptingStep` - The acceptingStep to set.

### getFileFormatTypeNr

    public int getFileFormatTypeNr()

  Specified by:
    `getFileFormatTypeNr` in interface `InputFileMetaInterface`

### getFileTypeNr

    public int getFileTypeNr()

### getResourceDependencies

    public List<ResourceReference> getResourceDependencies(TransMeta transMeta,
                                                           StepMeta stepInfo)

  Description copied from class: `BaseStepMeta`
  Get a list of all the resource dependencies that the step is depending on.

  Specified by:
    `getResourceDependencies` in interface `StepMetaInterface`
  Overrides:
    `getResourceDependencies` in class `BaseStepMeta`
  Returns:
    a list of all the resource dependencies that the step is depending on

### exportResources

    public String exportResources(org.pentaho.di.core.variables.VariableSpace space,
                                  Map<String,ResourceDefinition> definitions,
                                  ResourceNamingInterface resourceNamingInterface,
                                  Repository repository)
                           throws org.pentaho.di.core.exception.KettleException

  Since the exported transformation that runs this will reside in a ZIP file, we can't reference files relatively. So what this does is turn the name of files into absolute paths OR it simply includes the resource in the ZIP file. For now, we'll simply turn it into an absolute path and pray that the file is on a shared drive or something like that. TODO: create options to configure this behavior

  Specified by:
    `exportResources` in interface `StepMetaInterface`
  Overrides:
    `exportResources` in class `BaseStepMeta`
  Parameters:
    `space` - the variable space to use
    `repository` - The repository to optionally load other resources from (to be converted to XML)
  Returns:
    the filename of the exported resource
  Throws:
    `org.pentaho.di.core.exception.KettleException`

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