Uses of Class
org.knime.core.node.ExecutionContext

Packages that use ExecutionContext
org.knime.base.collection.list.create Implementation of the collection create node. 
org.knime.base.collection.list.split Implementation of the collection split node. 
org.knime.base.data.sort   
org.knime.base.data.statistics This package holds the StatisticsTable. 
org.knime.base.node.flowvariable.appendvariabletotable   
org.knime.base.node.flowvariable.extractvariables   
org.knime.base.node.flowvariable.injectvariables   
org.knime.base.node.flowvariable.tablerowtovariable   
org.knime.base.node.flowvariable.variableloophead   
org.knime.base.node.flowvariable.variabletotablerow   
org.knime.base.node.io.arffreader Contains the implementation of a node which reads ARFF files. 
org.knime.base.node.io.arffwriter Contains the implementation of a node which writes the content of a data table into an ARFF file. 
org.knime.base.node.io.csvwriter Node implementation that writes a DataTable to a file in CSV (comma separated value) format (or with any other selectable separator). 
org.knime.base.node.io.database Contains nodes to access data via a database connection. 
org.knime.base.node.io.def (Obsolete) Node that produces predefined DataTables. 
org.knime.base.node.io.filereader Contains a node implementation that reads in data from an ASCII file. 
org.knime.base.node.io.pmml.read   
org.knime.base.node.io.pmml.write   
org.knime.base.node.io.portobject Contains node implementations for a prediction model reader and writer. 
org.knime.base.node.io.table.read Node that reads data from a file as written by the Write table node. 
org.knime.base.node.io.table.write Node that writes a datatable to a file. 
org.knime.base.node.meta.feature.backwardelim   
org.knime.base.node.meta.looper The looper package contains all classes for building for loops. 
org.knime.base.node.meta.looper.condition Contains two nodes with which a loop can be built. 
org.knime.base.node.meta.xvalidation The xvalidation package contains all classes for a cross validation flow. 
org.knime.base.node.mine.bayes.naivebayes.datamodel This package implements the naive bayes algorithm for numerical and nominal attributes. 
org.knime.base.node.mine.bayes.naivebayes.learner This package contains the classes of the learner node. 
org.knime.base.node.mine.bayes.naivebayes.predictor This package contains the classes of the predictor node. 
org.knime.base.node.mine.bfn Contains abstract and util classes to train and perform prediction to rule models, also called BasisFunction models. 
org.knime.base.node.mine.bfn.fuzzy Contains the learner and predictor to train fuzzy rules and apply them to unknown data. 
org.knime.base.node.mine.cluster.assign This package contains the classes for the Cluster Assigner Node. 
org.knime.base.node.mine.cluster.fuzzycmeans The fuzzycmeans package contains all classes for the Fuzzy c-means node. 
org.knime.base.node.mine.cluster.hierarchical Contains the implementation of a node performing hierarchical clustering. 
org.knime.base.node.mine.cluster.kmeans This package contains the classes needed from the KMeans Node. 
org.knime.base.node.mine.decisiontree2.learner   
org.knime.base.node.mine.decisiontree2.predictor This package contains code for a decision tree model and predictor. 
org.knime.base.node.mine.knn   
org.knime.base.node.mine.mds A node that applies multi dimensional scaling (MDS) on high dimensional data. 
org.knime.base.node.mine.mds.mdsprojection A node that applies multi dimensional scaling (MDS) projection on high dimensional data. 
org.knime.base.node.mine.neural.mlp This package contains the classes for the MultiLayerPerceptron Predictor node. 
org.knime.base.node.mine.neural.rprop This package contains all classes for the RProp Node. 
org.knime.base.node.mine.pca This package contains all classes for the PCA (principal component analysis) Node. 
org.knime.base.node.mine.regression.linear.learn Node implementation performing linear regression. 
org.knime.base.node.mine.regression.polynomial.learner The polyreg's predictor package contains just the two classes that make up the predictor node: the model and its factory. 
org.knime.base.node.mine.regression.predict Node implementation performing regression prediction. 
org.knime.base.node.mine.scorer.accuracy Similar to the default scorer. 
org.knime.base.node.mine.scorer.entrop Node that performs an entropy calculation and compares two clustering results. 
org.knime.base.node.mine.smote Node that oversample patterns in an input table. 
org.knime.base.node.mine.sota Contains the Sota node, which can be used for clustering hirarchically numerical and fuzzy data and visualize the resulting cluster tree. 
org.knime.base.node.mine.sota.predictor Contains the Sotapredictor node, which can be used for class prediction of incoming data. 
org.knime.base.node.mine.subgroupminer This package contains everything necessary for normal subgroup mining. 
org.knime.base.node.mine.svm.learner This subpackage contains all classes for the SVM Learner Node. 
org.knime.base.node.mine.svm.predictor This subpackage contains all classes for the SVM Predictor Node. 
org.knime.base.node.parallel This subpackage contains some classes that can be used to implemet nodes that process their data in parallel. 
org.knime.base.node.parallel.appender   
org.knime.base.node.parallel.builder   
org.knime.base.node.preproc.append.row   
org.knime.base.node.preproc.binner Contains a node to bin/group a number of numeric columns into a string column by predefined intervals. 
org.knime.base.node.preproc.caseconvert Node to convert alphanumeric characters to lowercase or uppercase. 
org.knime.base.node.preproc.cellsplit Contains the implementation of a node that splits (and replaces) a values in a column into multiple new ones. 
org.knime.base.node.preproc.cellsplitbypos   
org.knime.base.node.preproc.colcombine Node to combine the content of a set of columns into a single column (to be appended). 
org.knime.base.node.preproc.colcompare Node to combine the content of a set of columns into a single column (to be appended). 
org.knime.base.node.preproc.colconvert Node to convert String columns to Double columns or the other way around. 
org.knime.base.node.preproc.colconvert.numbertostring Node to convert DoubleValue columns to StringValue columns. 
org.knime.base.node.preproc.colconvert.stringtonumber Node to convert StringValue columns to NumberValue columns. 
org.knime.base.node.preproc.colsort This package contains all classes for the Column Resorter node. 
org.knime.base.node.preproc.columnTrans This package contains the classes of the Many2One and One2Many column transformation nodes. 
org.knime.base.node.preproc.correlation.pmcc   
org.knime.base.node.preproc.discretization.caim2.modelapply Contains the classes implementing a node that applies a discretization (binning) model to new data. 
org.knime.base.node.preproc.discretization.caim2.modelcreator Contains the classes implementing a node that learns a class supervised discretization (binning) model. 
org.knime.base.node.preproc.domain Contains a node to determine the DataTableSpec of the input data. 
org.knime.base.node.preproc.double2int   
org.knime.base.node.preproc.filter.column Contains the filter column node which can be used the extract certain columns from the input data table. 
org.knime.base.node.preproc.filter.columnref Contains a Reference Column Filter node that allows columns to be included or excluded from the first table while the second one is used as reference table. 
org.knime.base.node.preproc.filter.hilite Node to seperate hilited and not hilited rows of given DataTable. 
org.knime.base.node.preproc.filter.hilite.collector Contains the HiLite Collector node with can be used to apply annotations to a set of hilit rows. 
org.knime.base.node.preproc.filter.nominal This package implements a possible value row filter. 
org.knime.base.node.preproc.filter.row Contains a node filtering out rows from an input data table, including only those rows into the output/result table that match a certain criteria. 
org.knime.base.node.preproc.filter.rowref Contains a Reference Row Filter node that allows rows to be included or excluded from the first table while the second one is used as reference table. 
org.knime.base.node.preproc.groupby Contains a node to perform a group by operation on an input table. 
org.knime.base.node.preproc.joiner This package contains classes for a node that joins two data tables. 
org.knime.base.node.preproc.lowvarfilter Node implementation that allows the user to filter out numeric columns, which have a low or no variance. 
org.knime.base.node.preproc.missingval Implemenation of the node that treats missing values. 
org.knime.base.node.preproc.normalize This package contains all classes for the Normalizer Node. 
org.knime.base.node.preproc.partition Node that partitions the data into train- and test set. 
org.knime.base.node.preproc.pivot Contains a node to perform a pivoting on one column against another group column. 
org.knime.base.node.preproc.regexsplit Node that splits an input string (column) into multiple groups according to a regular expression (realized by java.util.regex.Pattern). 
org.knime.base.node.preproc.rename Node that allows to rename column names or change the type. 
org.knime.base.node.preproc.rowkey This package contains all classes of the RowKey node which provides the following function: Replacing of the current rowkey with the values of a column Creating a column with the row key values  
org.knime.base.node.preproc.rowsplit Node splits a data table according to a numeric filter criterion. 
org.knime.base.node.preproc.sample Node that samples rows from an input table. 
org.knime.base.node.preproc.setoperator Contains a node to perform a set operation on two columns from two input tables. 
org.knime.base.node.preproc.shuffle Implementation of the Fisher Yates shuffle, that guarantees that all n! possible outcomes are possible and equally likely. 
org.knime.base.node.preproc.sorter Contains the Sorter Node which can be used to sort columns from the input data table. 
org.knime.base.node.preproc.split Node that splits an input table into two output table. 
org.knime.base.node.preproc.stringreplacer This package contains a node that can be used to replace strings in a column based on wildcard matches. 
org.knime.base.node.preproc.stringreplacer.dict Node that replaces the content of a selected column by dictionary entries. 
org.knime.base.node.preproc.transpose Contains a node to transpose a table by swaping rows and columns. 
org.knime.base.node.preproc.unpivot   
org.knime.base.node.preproc.valcount   
org.knime.base.node.rules   
org.knime.base.node.util.cache Contains node that allows caching of data for fast access. 
org.knime.base.node.util.exttool Provides functionality for nodes that want to launch external programs.
The CommandExecution can be used to run the external program. 
org.knime.base.node.util.sampledata   
org.knime.base.node.viz.condbox Contains all classes that realize a conditional box plot. 
org.knime.base.node.viz.enrichment The enrichment plotter node allows you to plot enrichment curves. 
org.knime.base.node.viz.histogram.node Contains classes for KNIME nodes which uses the classes of the histogram package to display a histogram view. 
org.knime.base.node.viz.liftchart The liftchart package contains all classes for building a lift chart node. 
org.knime.base.node.viz.pie.node This package contains the KNIME node classes for the fixed and interactive pie chart. 
org.knime.base.node.viz.pie.node.fixed This package contains the KNIME node classes for the fixed pie chart. 
org.knime.base.node.viz.pie.node.interactive This package contains the KNIME node classes for the interactive pie chart. 
org.knime.base.node.viz.plotter.box Contains all classes that realize a box plot. 
org.knime.base.node.viz.plotter.node This package contains a default node implementation which can be used if a simple plotter is implemented, which displays data from one inport and also wants to display only a restricted number of rows. 
org.knime.base.node.viz.property.color Contains the Color Manager and Color Appender node to set colors for a nominal or bounded (numeric) column. 
org.knime.base.node.viz.property.shape Contains the Shape Manager and Shape Appender node to set shapes for a nominal column. 
org.knime.base.node.viz.property.size Contains the Size Manager and Size Appender node to set sizes for a bounded (numeric) column. 
org.knime.base.node.viz.roc The ROC node allows you to plot ROC curves. 
org.knime.base.node.viz.statistics Contains the Statistics Node which can be used to compute statistics based on the input data table. 
org.knime.base.node.viz.table Node implementation of the interactive table view. 
org.knime.core.data.container Implementation of a DataContainer
org.knime.core.node Contains all classes needed to implement a new node in the workflow. 
org.knime.core.node.interrupt This package contains the necessary classes for an interruptible framework. 
org.knime.core.node.port.database   
org.knime.core.node.util Contains a set of utility classes that may be used in different (so far visual) contexts. 
org.knime.core.node.workflow Contains wrapper classes which control the communication between Node and GUI Workflow. 
 

Uses of ExecutionContext in org.knime.base.collection.list.create
 

Methods in org.knime.base.collection.list.create with parameters of type ExecutionContext
protected  BufferedDataTable[] CollectionCreateNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.collection.list.split
 

Methods in org.knime.base.collection.list.split with parameters of type ExecutionContext
protected  BufferedDataTable[] CollectionSplitNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.data.sort
 

Constructors in org.knime.base.data.sort with parameters of type ExecutionContext
SortedTable(BufferedDataTable dataTable, Comparator<DataRow> rowComparator, boolean sortInMemory, ExecutionContext exec)
          Creates a new sorted table.
SortedTable(BufferedDataTable dataTable, List<String> inclList, boolean[] sortAscending, boolean sortInMemory, ExecutionContext exec)
          Creates a sorted table from the given table and the sorting parameters.
SortedTable(BufferedDataTable dataTable, List<String> inclList, boolean[] sortAscending, ExecutionContext exec)
          Creates a sorted table from the given table and the sorting parameters.
 

Uses of ExecutionContext in org.knime.base.data.statistics
 

Constructors in org.knime.base.data.statistics with parameters of type ExecutionContext
Statistics2Table(BufferedDataTable table, boolean computeMedian, int numNomValuesOutput, List<String> nominalValueColumns, ExecutionContext exec)
          Create new statistic table from an existing one.
 

Uses of ExecutionContext in org.knime.base.node.flowvariable.appendvariabletotable
 

Methods in org.knime.base.node.flowvariable.appendvariabletotable with parameters of type ExecutionContext
protected  PortObject[] AppendVariableToTableNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.flowvariable.extractvariables
 

Methods in org.knime.base.node.flowvariable.extractvariables with parameters of type ExecutionContext
protected  PortObject[] ExtractVariablesNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.flowvariable.injectvariables
 

Methods in org.knime.base.node.flowvariable.injectvariables with parameters of type ExecutionContext
protected  PortObject[] InjectVariablesNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.flowvariable.tablerowtovariable
 

Methods in org.knime.base.node.flowvariable.tablerowtovariable with parameters of type ExecutionContext
protected  PortObject[] TableToVariableNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.flowvariable.variableloophead
 

Methods in org.knime.base.node.flowvariable.variableloophead with parameters of type ExecutionContext
protected  PortObject[] LoopStartVariableNodeModel.execute(PortObject[] inPOs, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.flowvariable.variabletotablerow
 

Methods in org.knime.base.node.flowvariable.variabletotablerow with parameters of type ExecutionContext
protected  PortObject[] VariableToTableNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.io.arffreader
 

Methods in org.knime.base.node.io.arffreader with parameters of type ExecutionContext
protected  BufferedDataTable[] ARFFReaderNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.io.arffwriter
 

Methods in org.knime.base.node.io.arffwriter with parameters of type ExecutionContext
protected  BufferedDataTable[] ARFFWriterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.io.csvwriter
 

Methods in org.knime.base.node.io.csvwriter with parameters of type ExecutionContext
protected  BufferedDataTable[] CSVWriterNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.io.database
 

Methods in org.knime.base.node.io.database with parameters of type ExecutionContext
protected  BufferedDataTable[] DBReaderNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] DBWriterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] DatabaseLoopingNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  PortObject[] DBRowFilterNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] DBConnectionNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] DBColumnFilterNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] DBQueryNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] DBReaderConnectionNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] DBConnectionWriterNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.io.def
 

Methods in org.knime.base.node.io.def with parameters of type ExecutionContext
protected  BufferedDataTable[] DefaultTableNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.io.filereader
 

Methods in org.knime.base.node.io.filereader with parameters of type ExecutionContext
protected  BufferedDataTable[] FileReaderNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  PortObject[] VariableFileReaderNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Constructors in org.knime.base.node.io.filereader with parameters of type ExecutionContext
FileReaderPreviewTable(DataTableSpec tableSpec, FileReaderNodeSettings settings, ExecutionContext exec)
          Creates a new table, its like the "normal" FileTable, just not failing on invalid data files.
FileRowIterator(FileReaderSettings frSettings, DataTableSpec tableSpec, boolean[] skipColumns, ExecutionContext exec)
          The RowIterator for the FileTable.
FileTable(DataTableSpec tableSpec, FileReaderSettings frSettings, boolean[] skipColumns, ExecutionContext exec)
          Creates a new file table with the structure defined in tableSpec and using the settings in frSettings when the file is read.
FileTable(DataTableSpec tableSpec, FileReaderSettings frSettings, ExecutionContext exec)
          Creates a new file table with the structure defined in tableSpec and using the settings in frSettings when the file is read.
 

Uses of ExecutionContext in org.knime.base.node.io.pmml.read
 

Methods in org.knime.base.node.io.pmml.read with parameters of type ExecutionContext
protected  PortObject[] PMMLReaderNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.io.pmml.write
 

Methods in org.knime.base.node.io.pmml.write with parameters of type ExecutionContext
protected  PortObject[] PMMLWriterNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.io.portobject
 

Methods in org.knime.base.node.io.portobject with parameters of type ExecutionContext
protected  PortObject[] PortObjectWriterNodeModel.execute(PortObject[] portObject, ExecutionContext exec)
          Writes model as ModelContent to file.
protected  PortObject[] PortObjectReaderNodeModel.execute(PortObject[] data, ExecutionContext exec)
          Execute does nothing - the reading of the file and writing to the NodeSettings object has already happened during savePredictorParams.
 

Uses of ExecutionContext in org.knime.base.node.io.table.read
 

Methods in org.knime.base.node.io.table.read with parameters of type ExecutionContext
protected  BufferedDataTable[] ReadTableNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.io.table.write
 

Methods in org.knime.base.node.io.table.write with parameters of type ExecutionContext
protected  BufferedDataTable[] WriteTableNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.meta.feature.backwardelim
 

Methods in org.knime.base.node.meta.feature.backwardelim with parameters of type ExecutionContext
protected  BufferedDataTable[] BWElimLoopStartNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  PortObject[] BWElimFilterNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] BWElimLoopEndNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.meta.looper
 

Methods in org.knime.base.node.meta.looper with parameters of type ExecutionContext
protected  BufferedDataTable[] LoopEndNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  PortObject[] LoopStartIntervalNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] LoopStartCountNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.meta.looper.condition
 

Methods in org.knime.base.node.meta.looper.condition with parameters of type ExecutionContext
protected  BufferedDataTable[] LoopStartGenericNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] LoopEndConditionNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.meta.xvalidation
 

Methods in org.knime.base.node.meta.xvalidation with parameters of type ExecutionContext
protected  BufferedDataTable[] XValidatePartitionModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] AggregateOutputNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.mine.bayes.naivebayes.datamodel
 

Constructors in org.knime.base.node.mine.bayes.naivebayes.datamodel with parameters of type ExecutionContext
NaiveBayesModel(BufferedDataTable data, String classColName, ExecutionContext exec, int maxNoOfNominalVals, boolean skipMissingVals)
          Constructor which iterates through the DataTable to calculate the needed Bayes variables.
 

Uses of ExecutionContext in org.knime.base.node.mine.bayes.naivebayes.learner
 

Methods in org.knime.base.node.mine.bayes.naivebayes.learner with parameters of type ExecutionContext
protected  PortObject[] NaiveBayesLearnerNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.bayes.naivebayes.predictor
 

Methods in org.knime.base.node.mine.bayes.naivebayes.predictor with parameters of type ExecutionContext
protected  PortObject[] NaiveBayesPredictorNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.bfn
 

Methods in org.knime.base.node.mine.bfn with parameters of type ExecutionContext
 PortObject[] BasisFunctionLearnerNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Starts the learning algorithm in the learner.
 BufferedDataTable[] BasisFunctionPredictorNodeModel.execute(PortObject[] portObj, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.bfn.fuzzy
 

Methods in org.knime.base.node.mine.bfn.fuzzy with parameters of type ExecutionContext
 PortObject[] FuzzyBasisFunctionLearnerNodeModel.execute(PortObject[] data, ExecutionContext exec)
          Starts the learning algorithm in the learner.
 

Uses of ExecutionContext in org.knime.base.node.mine.cluster.assign
 

Methods in org.knime.base.node.mine.cluster.assign with parameters of type ExecutionContext
protected  PortObject[] ClusterAssignerNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.cluster.fuzzycmeans
 

Methods in org.knime.base.node.mine.cluster.fuzzycmeans with parameters of type ExecutionContext
 double FCMAlgorithmMemory.doOneIteration(ExecutionContext exec)
          Does one iteration in the Fuzzy c-means algorithm.
 double FCMAlgorithm.doOneIteration(ExecutionContext exec)
          Does one iteration in the Fuzzy c-means algorithm.
protected  PortObject[] FuzzyClusterNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Generate new clustering based on InputDataTable and specified number of clusters.
 

Uses of ExecutionContext in org.knime.base.node.mine.cluster.hierarchical
 

Methods in org.knime.base.node.mine.cluster.hierarchical with parameters of type ExecutionContext
protected  BufferedDataTable[] HierarchicalClusterNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.mine.cluster.kmeans
 

Methods in org.knime.base.node.mine.cluster.kmeans with parameters of type ExecutionContext
protected  PortObject[] ClusterNodeModel.execute(PortObject[] data, ExecutionContext exec)
          Generate new clustering based on InputDataTable and specified number of clusters.
 

Uses of ExecutionContext in org.knime.base.node.mine.decisiontree2.learner
 

Methods in org.knime.base.node.mine.decisiontree2.learner with parameters of type ExecutionContext
 InMemoryTable InMemoryTableCreator.createInMemoryTable(ExecutionContext exec)
          Creates the InMemoryTable.
protected  PortObject[] DecisionTreeLearnerNodeModel.execute(PortObject[] data, ExecutionContext exec)
          Start of decision tree induction.
 

Uses of ExecutionContext in org.knime.base.node.mine.decisiontree2.predictor
 

Methods in org.knime.base.node.mine.decisiontree2.predictor with parameters of type ExecutionContext
protected  PortObject[] DecTreePredictorNodeModel.execute(PortObject[] inPorts, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.knn
 

Methods in org.knime.base.node.mine.knn with parameters of type ExecutionContext
protected  BufferedDataTable[] KnnNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.mine.mds
 

Methods in org.knime.base.node.mine.mds with parameters of type ExecutionContext
protected  BufferedDataTable[] MDSNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Constructors in org.knime.base.node.mine.mds with parameters of type ExecutionContext
MDSManager(int dimension, String distance, boolean fuzzy, BufferedDataTable inData, ExecutionContext exec)
          Creates a new instance of MDSManager with the given dimension, distance metric, fuzzy flag and in data to use.
 

Uses of ExecutionContext in org.knime.base.node.mine.mds.mdsprojection
 

Fields in org.knime.base.node.mine.mds.mdsprojection declared as ExecutionContext
protected  ExecutionContext MDSProjectionManager.m_exec
          The execution context to show progress information an enable cancel.
 

Methods in org.knime.base.node.mine.mds.mdsprojection with parameters of type ExecutionContext
protected  BufferedDataTable[] MDSProjectionNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Constructors in org.knime.base.node.mine.mds.mdsprojection with parameters of type ExecutionContext
MDSProjectionManager(int dimension, String distance, boolean fuzzy, BufferedDataTable inData, BufferedDataTable fixedDataPoints, int[] fixedDataMdsIndices, ExecutionContext exec)
          Creates a new instance of MDSProjectionManager with the given dimension, distance metric, fuzzy flag, in data and fixed data to use.
 

Uses of ExecutionContext in org.knime.base.node.mine.neural.mlp
 

Methods in org.knime.base.node.mine.neural.mlp with parameters of type ExecutionContext
protected  PortObject[] MLPPredictorNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.neural.rprop
 

Methods in org.knime.base.node.mine.neural.rprop with parameters of type ExecutionContext
protected  PortObject[] RPropNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          The execution consists of three steps: A neural network is build with the inputs and outputs according to the input datatable, number of hidden layers as specified. Input DataTables are converted into double-arrays so they can be attached to the neural net. The neural net is trained. Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.pca
 

Methods in org.knime.base.node.mine.pca with parameters of type ExecutionContext
static BufferedDataTable PCANodeModel.createCovarianceTable(ExecutionContext exec, double[][] m, String[] inputColumnNames)
          create data table from covariance matrix.
static BufferedDataTable PCANodeModel.createDecompositionOutputTable(ExecutionContext exec, double[] evs, Jama.Matrix eigenvectors)
          create a table containing the given spectral decomposition.
protected  PortObject[] PCAApplyNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Performs the PCA.
protected  PortObject[] PCAReverseNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Performs the PCA.
protected  PortObject[] PCAComputeNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] PCANodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Performs the PCA.
(package private) static int PCANodeModel.getCovarianceMatrix(ExecutionContext exec, BufferedDataTable dataTable, int[] numericIndices, double[] means, double[][] dataMatrix)
          Converts a DataTable to the 2D-double array representing its covariance matrix.
(package private) static double[] PCANodeModel.getMeanVector(DataTable dataTable, int[] numericIndices, boolean failOnMissingValues, ExecutionContext exec)
          calculate means of all columns.
 

Uses of ExecutionContext in org.knime.base.node.mine.regression.linear.learn
 

Methods in org.knime.base.node.mine.regression.linear.learn with parameters of type ExecutionContext
protected  PortObject[] LinRegLearnerNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.regression.polynomial.learner
 

Methods in org.knime.base.node.mine.regression.polynomial.learner with parameters of type ExecutionContext
protected  PortObject[] PolyRegLearnerNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.regression.predict
 

Methods in org.knime.base.node.mine.regression.predict with parameters of type ExecutionContext
protected  PortObject[] RegressionPredictorNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.scorer.accuracy
 

Methods in org.knime.base.node.mine.scorer.accuracy with parameters of type ExecutionContext
protected  BufferedDataTable[] AccuracyScorerNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          Starts the scoring in the scorer.
 

Uses of ExecutionContext in org.knime.base.node.mine.scorer.entrop
 

Methods in org.knime.base.node.mine.scorer.entrop with parameters of type ExecutionContext
protected  BufferedDataTable[] EntropyNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.mine.smote
 

Methods in org.knime.base.node.mine.smote with parameters of type ExecutionContext
protected  BufferedDataTable[] SmoteNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Constructors in org.knime.base.node.mine.smote with parameters of type ExecutionContext
Smoter(BufferedDataTable in, String colName, ExecutionContext exec, Random rand)
          Creates a new instance given the input table in and the target column colName.
 

Uses of ExecutionContext in org.knime.base.node.mine.sota
 

Methods in org.knime.base.node.mine.sota with parameters of type ExecutionContext
protected  PortObject[] SotaNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.sota.predictor
 

Methods in org.knime.base.node.mine.sota.predictor with parameters of type ExecutionContext
protected  PortObject[] SotaPredictorNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.subgroupminer
 

Methods in org.knime.base.node.mine.subgroupminer with parameters of type ExecutionContext
protected  BufferedDataTable[] BitVectorGeneratorNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] SubgroupMinerModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.mine.svm.learner
 

Methods in org.knime.base.node.mine.svm.learner with parameters of type ExecutionContext
protected  PortObject[] SVMLearnerNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.mine.svm.predictor
 

Methods in org.knime.base.node.mine.svm.predictor with parameters of type ExecutionContext
protected  PortObject[] SVMPredictorNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.parallel
 

Methods in org.knime.base.node.parallel with parameters of type ExecutionContext
protected  BufferedDataTable[] AbstractParallelNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.parallel.appender
 

Methods in org.knime.base.node.parallel.appender with parameters of type ExecutionContext
protected  BufferedDataTable[] ThreadedColAppenderNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] ThreadedColAppenderNodeModel.postExecute(BufferedDataTable[] res, ExecutionContext exec)
          This method is called after all rows have been processed and combined into the final result tables.
 

Uses of ExecutionContext in org.knime.base.node.parallel.builder
 

Methods in org.knime.base.node.parallel.builder with parameters of type ExecutionContext
protected  BufferedDataTable[] ThreadedTableBuilderNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.append.row
 

Methods in org.knime.base.node.preproc.append.row with parameters of type ExecutionContext
protected  BufferedDataTable[] AppendedRowsNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.binner
 

Methods in org.knime.base.node.preproc.binner with parameters of type ExecutionContext
protected  BufferedDataTable[] BinnerNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.caseconvert
 

Methods in org.knime.base.node.preproc.caseconvert with parameters of type ExecutionContext
protected  BufferedDataTable[] CaseConvertNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.cellsplit
 

Methods in org.knime.base.node.preproc.cellsplit with parameters of type ExecutionContext
(package private) static CellSplitterSettings CellSplitterCellFactory.createNewColumnTypes(BufferedDataTable table, CellSplitterUserSettings userSettings, ExecutionContext exec)
          Analyzes the values in the user selected column and tries to figure out how many columns are needed to hold the splitted values and of which type the new resulting column have to be.
protected  BufferedDataTable[] CellSplitterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.cellsplitbypos
 

Methods in org.knime.base.node.preproc.cellsplitbypos with parameters of type ExecutionContext
protected  BufferedDataTable[] CellSplitterByPosNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.colcombine
 

Methods in org.knime.base.node.preproc.colcombine with parameters of type ExecutionContext
protected  BufferedDataTable[] ColCombineNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.colcompare
 

Methods in org.knime.base.node.preproc.colcompare with parameters of type ExecutionContext
protected  BufferedDataTable[] ColumnComparatorNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.colconvert
 

Methods in org.knime.base.node.preproc.colconvert with parameters of type ExecutionContext
protected  BufferedDataTable[] ColConvertNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.colconvert.numbertostring
 

Methods in org.knime.base.node.preproc.colconvert.numbertostring with parameters of type ExecutionContext
protected  BufferedDataTable[] NumberToStringNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.colconvert.stringtonumber
 

Methods in org.knime.base.node.preproc.colconvert.stringtonumber with parameters of type ExecutionContext
protected  BufferedDataTable[] StringToNumberNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.colsort
 

Methods in org.knime.base.node.preproc.colsort with parameters of type ExecutionContext
protected  BufferedDataTable[] ColumnResorterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.columnTrans
 

Methods in org.knime.base.node.preproc.columnTrans with parameters of type ExecutionContext
protected  BufferedDataTable[] One2ManyColNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] Many2OneColNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.correlation.pmcc
 

Methods in org.knime.base.node.preproc.correlation.pmcc with parameters of type ExecutionContext
(package private)  BufferedDataTable PMCCPortObjectAndSpec.createCorrelationMatrix(ExecutionContext con)
          Creates the correlation table, used in the view and as output table.
protected  PortObject[] PMCCFilterNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] PMCCNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.preproc.discretization.caim2.modelapply
 

Methods in org.knime.base.node.preproc.discretization.caim2.modelapply with parameters of type ExecutionContext
protected  PortObject[] DiscretizationApplyNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.preproc.discretization.caim2.modelcreator
 

Methods in org.knime.base.node.preproc.discretization.caim2.modelcreator with parameters of type ExecutionContext
static BufferedDataTable CAIMDiscretizationNodeModel.createResultTable(ExecutionContext exec, BufferedDataTable table, DiscretizationModel discretizationModel)
          Creates BufferedDataTable from a given input table and an appropriate DiscretizationScheme.
protected  PortObject[] CAIMDiscretizationNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.preproc.domain
 

Methods in org.knime.base.node.preproc.domain with parameters of type ExecutionContext
protected  BufferedDataTable[] DomainNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.double2int
 

Methods in org.knime.base.node.preproc.double2int with parameters of type ExecutionContext
protected  BufferedDataTable[] DoubleToIntNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.filter.column
 

Methods in org.knime.base.node.preproc.filter.column with parameters of type ExecutionContext
protected  BufferedDataTable[] FilterColumnNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.filter.columnref
 

Methods in org.knime.base.node.preproc.filter.columnref with parameters of type ExecutionContext
protected  BufferedDataTable[] ColumnFilterRefNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.filter.hilite
 

Methods in org.knime.base.node.preproc.filter.hilite with parameters of type ExecutionContext
protected  BufferedDataTable[] HiliteFilterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.filter.hilite.collector
 

Methods in org.knime.base.node.preproc.filter.hilite.collector with parameters of type ExecutionContext
protected  PortObject[] HiLiteCollectorNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.preproc.filter.nominal
 

Methods in org.knime.base.node.preproc.filter.nominal with parameters of type ExecutionContext
protected  BufferedDataTable[] NominalValueRowFilterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.filter.row
 

Methods in org.knime.base.node.preproc.filter.row with parameters of type ExecutionContext
protected  BufferedDataTable[] RowFilterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
protected  BufferedDataTable[] RowFilter2PortNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.filter.rowref
 

Methods in org.knime.base.node.preproc.filter.rowref with parameters of type ExecutionContext
protected  BufferedDataTable[] RowFilterRefNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.groupby
 

Methods in org.knime.base.node.preproc.groupby with parameters of type ExecutionContext
protected  PortObject[] GroupByNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Constructors in org.knime.base.node.preproc.groupby with parameters of type ExecutionContext
GroupByTable(ExecutionContext exec, BufferedDataTable inDataTable, List<String> groupByCols, ColumnAggregator[] colAggregators, int maxUniqueValues, boolean sortInMemory, boolean enableHilite, ColumnNamePolicy colNamePolicy)
          Constructor for class GroupByTable.
GroupByTable(ExecutionContext exec, BufferedDataTable inDataTable, List<String> groupByCols, ColumnAggregator[] colAggregators, int maxUniqueValues, boolean sortInMemory, boolean enableHilite, ColumnNamePolicy colNamePolicy, boolean retainOrder)
          Constructor for class GroupByTable.
 

Uses of ExecutionContext in org.knime.base.node.preproc.joiner
 

Methods in org.knime.base.node.preproc.joiner with parameters of type ExecutionContext
protected  BufferedDataTable[] NewJoinerNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.lowvarfilter
 

Methods in org.knime.base.node.preproc.lowvarfilter with parameters of type ExecutionContext
protected  BufferedDataTable[] LowVarFilterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.missingval
 

Methods in org.knime.base.node.preproc.missingval with parameters of type ExecutionContext
static BufferedDataTable MissingValueHandlingTable.createMissingValueHandlingTable(DataTable table, ColSetting[] colSettings, ExecutionContext exec, StringBuffer warningBuffer)
          Does missing value handling to the argument table given the col settings in an array and also reports progress.
protected  BufferedDataTable[] MissingValueHandlingNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.normalize
 

Methods in org.knime.base.node.preproc.normalize with parameters of type ExecutionContext
protected  PortObject[] NormalizerApplyNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] NormalizerNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          New normalized DataTable is created depending on the mode.
 

Uses of ExecutionContext in org.knime.base.node.preproc.partition
 

Methods in org.knime.base.node.preproc.partition with parameters of type ExecutionContext
protected  BufferedDataTable[] PartitionNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.pivot
 

Methods in org.knime.base.node.preproc.pivot with parameters of type ExecutionContext
protected  BufferedDataTable[] PivotNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.regexsplit
 

Methods in org.knime.base.node.preproc.regexsplit with parameters of type ExecutionContext
protected  BufferedDataTable[] RegexSplitNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.rename
 

Methods in org.knime.base.node.preproc.rename with parameters of type ExecutionContext
protected  BufferedDataTable[] RenameNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.rowkey
 

Methods in org.knime.base.node.preproc.rowkey with parameters of type ExecutionContext
 BufferedDataTable RowKeyUtil.changeRowKey(BufferedDataTable inData, ExecutionContext exec, String selRowKeyColName, boolean appendColumn, DataColumnSpec newColSpec, boolean ensureUniqueness, boolean replaceMissingVals, boolean removeRowKeyCol, boolean hiliteMap)
          Replaces the row key by the values of the column with the given name and appends a new column with the old key values if the newColName variable is a non empty String.
protected  BufferedDataTable[] RowKeyNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.rowsplit
 

Methods in org.knime.base.node.preproc.rowsplit with parameters of type ExecutionContext
protected  BufferedDataTable[] NumericRowSplitterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.sample
 

Methods in org.knime.base.node.preproc.sample with parameters of type ExecutionContext
protected  BufferedDataTable[] SamplingNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.setoperator
 

Methods in org.knime.base.node.preproc.setoperator with parameters of type ExecutionContext
protected  BufferedDataTable[] SetOperatorNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Constructors in org.knime.base.node.preproc.setoperator with parameters of type ExecutionContext
SetOperationTable(ExecutionContext exec, boolean useRowID1, String col1, BufferedDataTable table1, boolean useRowID2, String col2, BufferedDataTable table2, SetOperation op, boolean enableHilite, boolean skipMissing, boolean sortInMemory)
          Constructor for class SetOperationTable.
 

Uses of ExecutionContext in org.knime.base.node.preproc.shuffle
 

Methods in org.knime.base.node.preproc.shuffle with parameters of type ExecutionContext
protected  BufferedDataTable[] ShuffleNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.sorter
 

Methods in org.knime.base.node.preproc.sorter with parameters of type ExecutionContext
protected  BufferedDataTable[] SorterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          When the model gets executed, the DataTable is split in several DataContainers.
 

Uses of ExecutionContext in org.knime.base.node.preproc.split
 

Methods in org.knime.base.node.preproc.split with parameters of type ExecutionContext
protected  BufferedDataTable[] SplitNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.stringreplacer
 

Methods in org.knime.base.node.preproc.stringreplacer with parameters of type ExecutionContext
protected  BufferedDataTable[] StringReplacerNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.stringreplacer.dict
 

Methods in org.knime.base.node.preproc.stringreplacer.dict with parameters of type ExecutionContext
protected  BufferedDataTable[] SearchReplaceDictNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.transpose
 

Methods in org.knime.base.node.preproc.transpose with parameters of type ExecutionContext
protected  BufferedDataTable[] TransposeTableNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.unpivot
 

Methods in org.knime.base.node.preproc.unpivot with parameters of type ExecutionContext
protected  BufferedDataTable[] UnpivotNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.preproc.valcount
 

Methods in org.knime.base.node.preproc.valcount with parameters of type ExecutionContext
protected  BufferedDataTable[] ValueCounterNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.rules
 

Methods in org.knime.base.node.rules with parameters of type ExecutionContext
protected  BufferedDataTable[] RuleEngineNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.util.cache
 

Methods in org.knime.base.node.util.cache with parameters of type ExecutionContext
protected  BufferedDataTable[] CacheNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.util.exttool
 

Methods in org.knime.base.node.util.exttool with parameters of type ExecutionContext
 int CommandExecution.execute(ExecutionContext exec)
          Executes the commands via the Runtime and streams the stdout as well as the stderr to the logger and notifies the registered observer if a msg occurs.
 

Uses of ExecutionContext in org.knime.base.node.util.sampledata
 

Methods in org.knime.base.node.util.sampledata with parameters of type ExecutionContext
protected  BufferedDataTable[] SampleDataNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.viz.condbox
 

Methods in org.knime.base.node.viz.condbox with parameters of type ExecutionContext
protected  BufferedDataTable[] ConditionalBoxPlotNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.viz.enrichment
 

Methods in org.knime.base.node.viz.enrichment with parameters of type ExecutionContext
protected  BufferedDataTable[] EnrichmentPlotterModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.viz.histogram.node
 

Methods in org.knime.base.node.viz.histogram.node with parameters of type ExecutionContext
protected  void FixedColumnHistogramNodeModel.createHistogramModel(ExecutionContext exec, int noOfRows, BufferedDataTable table)
          This method should use the given information to create the internal histogram data model.
protected  void HistogramNodeModel.createHistogramModel(ExecutionContext exec, int noOfRows, BufferedDataTable data)
          This method should use the given information to create the internal histogram data model.
protected abstract  void AbstractHistogramNodeModel.createHistogramModel(ExecutionContext exec, int noOfRows, BufferedDataTable table)
          This method should use the given information to create the internal histogram data model.
protected  PortObject[] AbstractHistogramNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.viz.liftchart
 

Methods in org.knime.base.node.viz.liftchart with parameters of type ExecutionContext
protected  BufferedDataTable[] LiftChartNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.viz.pie.node
 

Methods in org.knime.base.node.viz.pie.node with parameters of type ExecutionContext
protected abstract  void PieNodeModel.createModel(ExecutionContext exec, DataColumnSpec pieColSpec, DataColumnSpec aggrColSpec, BufferedDataTable dataTable, int noOfRows, boolean containsColorHandler)
          Called prior #addDataRow(...) method to allow the implementing class the specific model creation.
protected  BufferedDataTable[] PieNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.viz.pie.node.fixed
 

Methods in org.knime.base.node.viz.pie.node.fixed with parameters of type ExecutionContext
protected  void FixedPieNodeModel.createModel(ExecutionContext exec, DataColumnSpec pieColSpec, DataColumnSpec aggrColSpec, BufferedDataTable dataTable, int noOfRows, boolean containsColorHandler)
          Called prior #addDataRow(...) method to allow the implementing class the specific model creation.
 

Uses of ExecutionContext in org.knime.base.node.viz.pie.node.interactive
 

Methods in org.knime.base.node.viz.pie.node.interactive with parameters of type ExecutionContext
protected  void InteractivePieNodeModel.createModel(ExecutionContext exec, DataColumnSpec pieColSpec, DataColumnSpec aggrColSpec, BufferedDataTable dataTable, int noOfRows, boolean containsColorHandler)
          Called prior #addDataRow(...) method to allow the implementing class the specific model creation.
 

Uses of ExecutionContext in org.knime.base.node.viz.plotter.box
 

Methods in org.knime.base.node.viz.plotter.box with parameters of type ExecutionContext
protected  BufferedDataTable[] BoxPlotNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.viz.plotter.node
 

Methods in org.knime.base.node.viz.plotter.node with parameters of type ExecutionContext
protected  BufferedDataTable[] DefaultVisualizationNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          Converts the input data at inport 0 into a DataArray with maximum number of rows as defined in the DefaultVisualizationNodeDialog.
 

Uses of ExecutionContext in org.knime.base.node.viz.property.color
 

Methods in org.knime.base.node.viz.property.color with parameters of type ExecutionContext
protected  PortObject[] ColorAppender2NodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] ColorManager2NodeModel.execute(PortObject[] data, ExecutionContext exec)
          Is invoked during the node's execution to make the color settings.
 

Uses of ExecutionContext in org.knime.base.node.viz.property.shape
 

Methods in org.knime.base.node.viz.property.shape with parameters of type ExecutionContext
protected  PortObject[] ShapeManagerNodeModel.execute(PortObject[] data, ExecutionContext exec)
          Is invoked during the node's execution to make the shape settings.
protected  PortObject[] ShapeAppenderNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
 

Uses of ExecutionContext in org.knime.base.node.viz.property.size
 

Methods in org.knime.base.node.viz.property.size with parameters of type ExecutionContext
protected  PortObject[] SizeAppenderNodeModel.execute(PortObject[] inData, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] SizeManager2NodeModel.execute(PortObject[] data, ExecutionContext exec)
          Is invoked during the node's execution to make the size settings.
 

Uses of ExecutionContext in org.knime.base.node.viz.roc
 

Methods in org.knime.base.node.viz.roc with parameters of type ExecutionContext
protected  BufferedDataTable[] ROCNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 

Uses of ExecutionContext in org.knime.base.node.viz.statistics
 

Methods in org.knime.base.node.viz.statistics with parameters of type ExecutionContext
protected  BufferedDataTable[] Statistics2NodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          Computes the statistics for the DataTable at the in-port.
 

Uses of ExecutionContext in org.knime.base.node.viz.table
 

Methods in org.knime.base.node.viz.table with parameters of type ExecutionContext
protected  BufferedDataTable[] TableNodeModel.execute(BufferedDataTable[] data, ExecutionContext exec)
          Called when new data is available.
 

Uses of ExecutionContext in org.knime.core.data.container
 

Methods in org.knime.core.data.container with parameters of type ExecutionContext
static RearrangeColumnsTable RearrangeColumnsTable.create(ColumnRearranger rearranger, BufferedDataTable table, ExecutionMonitor subProgress, ExecutionContext context)
          This factory method is intended to be used immediately before the BufferedDataTable is created.
 

Uses of ExecutionContext in org.knime.core.node
 

Methods in org.knime.core.node that return ExecutionContext
 ExecutionContext ExecutionContext.createSilentSubExecutionContext(double maxProg)
          Creates a new execution context with a different max progress value and swallowing any report messages.
 ExecutionContext ExecutionContext.createSubExecutionContext(double maxProg)
          Creates a new execution context with a different max progress value.
 

Methods in org.knime.core.node with parameters of type ExecutionContext
protected  BufferedDataTable[] NodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          This function is invoked by the Node#executeNode() method of the node (through the #executeModel(BufferedDataTable[],ExecutionMonitor) method)only after all predecessor nodes have been successfully executed and all data is therefore available at the input ports.
 boolean Node.execute(PortObject[] data, ExecutionContext exec)
          Starts executing this node.
protected  PortObject[] NodeModel.execute(PortObject[] inObjects, ExecutionContext exec)
          Execute method for general port types.
protected  PortObject[] NodeModel.executeModel(PortObject[] data, ExecutionContext exec)
          Invokes the abstract #execute() method of this model.
static HashMap<Integer,ContainerTable> Node.getLocalTableRepositoryFromContext(ExecutionContext c)
          Delegate method to allow access to the (package scope) method getLocalTableRepository().
 

Uses of ExecutionContext in org.knime.core.node.interrupt
 

Methods in org.knime.core.node.interrupt with parameters of type ExecutionContext
 BufferedDataTable[] InterruptibleNodeModel.execute(BufferedDataTable[] inData, ExecutionContext exec)
          Initialises the NodeModel, starts the execution, pauses it, resumes it and finishes it.
abstract  void InterruptibleNodeModel.executeOneIteration(ExecutionContext exec)
          This method is assumed to implement one iteration of an interruptible algorithm.
abstract  BufferedDataTable[] InterruptibleNodeModel.getOutput(ExecutionContext exec)
          Is called at the end of the execute method when it is finished and the data should be available.
abstract  void InterruptibleNodeModel.init(BufferedDataTable[] inData, ExecutionContext exec)
          Do here the initialisation of the model.
 

Uses of ExecutionContext in org.knime.core.node.port.database
 

Methods in org.knime.core.node.port.database with parameters of type ExecutionContext
 BufferedDataTable DatabaseReaderConnection.createTable(ExecutionContext exec)
          Read data from database.
 

Uses of ExecutionContext in org.knime.core.node.util
 

Methods in org.knime.core.node.util with parameters of type ExecutionContext
 PortObject[] KNIMEJob.run(PortObject[] input, NodeSettingsRO settings, ExecutionContext exec)
          Runs the job somewhere.
 

Uses of ExecutionContext in org.knime.core.node.workflow
 

Methods in org.knime.core.node.workflow that return ExecutionContext
 ExecutionContext SingleNodeContainer.createExecutionContext()
           
 



Copyright, 2003 - 2010. All rights reserved.
University of Konstanz, Germany.
Chair for Bioinformatics and Information Mining, Prof. Dr. Michael R. Berthold.
You may not modify, publish, transmit, transfer or sell, reproduce, create derivative works from, distribute, perform, display, or in any way exploit any of the content, in whole or in part, except as otherwise expressly permitted in writing by the copyright owner or as specified in the license file distributed with this product.