import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@SuppressWarnings("deprecation")
@Override
protected DataTableSpec[] configure(final DataTableSpec[] inSpecs)
        throws InvalidSettingsException {

    m_classColIdx = NodeUtils.autoColumnSelection(inSpecs[DATA_PORT],
            m_classColModel, StringValue.class, this.getClass());

    m_repColIdx = NodeUtils.autoColumnSelection(inSpecs[DATA_PORT],
            m_repColModel, DataValue.class, this.getClass());

    m_renderer = inSpecs[DATA_PORT].getColumnSpec(m_repColIdx).getType()
            .getRenderer(inSpecs[DATA_PORT].getColumnSpec(m_repColIdx));

    m_colNames = inSpecs[DATA_PORT].getColumnNames();

    // Pass through
    if (inSpecs[PASSTHROUGH_PORT] != null) {
        return new DataTableSpec[] { inSpecs[PASSTHROUGH_PORT] };
    }
    // else route the input port
    return new DataTableSpec[] { inSpecs[DATA_PORT] };
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected DataTableSpec[] configure(final DataTableSpec[] inSpecs)
        throws InvalidSettingsException {

    // a^2
    final double alphaValue = m_radiusAlphaModel.getDoubleValue();
    m_alpha = 4.0d / (alphaValue * alphaValue);

    // a^2*rb^2
    m_beta = 4.0d / (alphaValue * alphaValue * FACTOR_RB * FACTOR_RB);

    m_exploitation = m_exploitationModel.getDoubleValue();

    m_classIdx = NodeUtils.autoColumnSelection(inSpecs[1], m_classColModel,
            StringValue.class, PBACScorerNodeModel.class);

    m_doubleIndices = NodeTools
            .collectAllColumnIndicesOfType(DoubleValue.class, inSpecs[0]);

    m_resSpec = createResRearranger(inSpecs[0]);

    return new DataTableSpec[] { m_resSpec.createSpec() };
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * {@inheritDoc} Variance based score.
 */
@Override
protected ColumnRearranger createResRearranger(final DataTableSpec inSpec)
        throws InvalidSettingsException {
    final ColumnRearranger rearranger = new ColumnRearranger(inSpec);
    final DataColumnSpec newColSpec =
            new DataColumnSpecCreator("Variance Score", DoubleCell.TYPE)
                    .createSpec();

    // utility object that performs the calculation
    rearranger.append(new SingleCellFactory(newColSpec) {
        final List<Integer> m_selectedIndicies =
                NodeTools.getIndicesFromFilter(inSpec, m_columnFilterModel,
                        DoubleValue.class, VarianceScorerNodeModel.class);

        @Override
        public DataCell getCell(final DataRow row) {
            return new DoubleCell(MathUtils.variance(
                    NodeTools.toDoubleArray(row, m_selectedIndicies)));
        }
    });
    return rearranger;
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
private ColumnRearranger createResRearranger(final DataTableSpec inSpec) {
    final ColumnRearranger rearranger = new ColumnRearranger(inSpec);
    rearranger.append(new CellFactory() {

        @Override
        public void setProgress(final int curRowNr, final int rowCount,
                final RowKey lastKey, final ExecutionMonitor exec) {
            exec.setProgress((double) curRowNr / rowCount);

        }

        @Override
        public DataColumnSpec[] getColumnSpecs() {
            return new DataColumnSpec[] {
                    new DataColumnSpecCreator("Graph Density Score",
                            DoubleCell.TYPE).createSpec() };
        }

        @Override
        public DataCell[] getCells(final DataRow row) {
            return new DataCell[] { new DoubleCell(
                    m_dataPoints.get(row.getKey()).getDensity()) };
        }
    });
    return rearranger;
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected DataTableSpec[] configure(final DataTableSpec[] inSpecs)
        throws InvalidSettingsException {

    if (NodeTools.collectAllColumnIndicesOfType(DoubleValue.class,
            inSpecs[UNLABELED_PORT]).isEmpty()) {
        throw new InvalidSettingsException("No Double columns avaiable!");
    }

    m_beta = 4.0d / ((m_radiusAlphaModel.getDoubleValue() * FACTOR_RB)
            * (m_radiusAlphaModel.getDoubleValue() * FACTOR_RB));

    m_alpha = 4.0d / (m_radiusAlphaModel.getDoubleValue()
            * m_radiusAlphaModel.getDoubleValue());

    m_resSpec = createResRearranger(inSpecs[UNLABELED_PORT]);

    return new DataTableSpec[] { m_resSpec.createSpec() };
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * Searches the first compatible column from the table specs.
 *
 * @param inSpec
 * @param valueClass
 * @param except
 *            columns that should not be chosen e.g. because they are
 *            already in use
 * @return the index of the first compatible column or -1 if no column in
 *         the table specs is compatible
 */
public static final int firstCompatibleColumn(final DataTableSpec inSpec,
        final Class<? extends DataValue> valueClass,
        final Integer... except) {

    final List<Integer> exceptList = (except == null
            ? new LinkedList<Integer>() : Arrays.asList(except));

    int i = 0;
    for (final DataColumnSpec colspec : inSpec) {
        if (colspec.getType().isCompatible(valueClass)
                && !exceptList.contains(i)) {
            return i;
        }
        i++;
    }
    return -1;
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * If setting holds a valid column name returns the column index. If not
 * search the first compatible column and return the index.
 *
 * @param inSpec
 * @param model
 * @param valueClass
 * @param except
 *            columns that should not be chosen e.g. because they are
 *            already in use
 * @return The column index, maybe -1, if not found
 */
public static final int silentOptionalAutoColumnSelection(
        final DataTableSpec inSpec, final SettingsModelString model,
        final Class<? extends DataValue> valueClass,
        final Integer... except) {

    int i = inSpec.findColumnIndex(model.getStringValue());
    if ((i > -1)
            && inSpec.getColumnSpec(i).getType().isCompatible(valueClass)) {
        return i;
    }
    i = autoOptionalColumnSelection(inSpec, model, valueClass, except);

    return i;

}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * Provides a safe method to get the indices of the selected columns from a
 * Filter Model, falls back on selecting all compatible types in case the
 * selection is invalid.
 *
 * @param spec
 *            the spec of the table.
 * @param filterModel
 *            the filter model that specifies the selection
 * @param valueClass
 *            the value class selected in case the selection is invalid
 * @param nodeModelClass
 *            node model class to be able to set right logger message
 *
 * @return the indices of the selected columns
 */
public static List<Integer> getIndicesFromFilter(final DataTableSpec spec,
        final SettingsModelColumnFilter2 filterModel,
        final Class<? extends DataValue> valueClass,
        final Class<? extends NodeModel> nodeModelClass) {

    final FilterResult result = filterModel.applyTo(spec);

    // in case of an invalid selection, select all
    if ((result.getIncludes().length == 0)
            && (result.getExcludes().length == 0)) {
        NodeLogger.getLogger(nodeModelClass)
                .warn("Invalid column selection, automatically selecting "
                        + "all columns of the following type: "
                        + valueClass.getSimpleName());
        return collectAllColumnIndicesOfType(valueClass, spec);
    }
    return columnNamesToIndices(result.getIncludes(), spec);
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * Update the settings and input spec.
 * @param settings the settings
 * @param spec the input spec
 * @param flowVars the available flow variables
 */
public void updateData(final JavaSnippetSettings settings,
        final DataTableSpec spec,
        final Map<String, FlowVariable> flowVars) {
    m_inListenerArmed = false;
    m_outListenerArmed = false;
    m_inFieldsTable.updateData(settings.getJavaSnippetFields(),
            spec, flowVars);
    m_outFieldsTable.updateData(settings.getJavaSnippetFields(),
            spec, flowVars);
    // update snippet.
    m_snippet.setJavaSnippetFields(new JavaSnippetFields(
            m_inFieldsTable.getInColFields(),
            m_inFieldsTable.getInVarFields(),
            m_outFieldsTable.getOutColFields(),
            m_outFieldsTable.getOutVarFields()));
    m_inListenerArmed = true;
    m_outListenerArmed = true;
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
private DataTableSpec createVcfDataColumnSpec()
{
DataColumnSpec[] allColSpecs = new DataColumnSpec[11];

   allColSpecs[0] =  new DataColumnSpecCreator("CHROM", StringCell.TYPE).createSpec();
   allColSpecs[1] =  new DataColumnSpecCreator("POS", IntCell.TYPE).createSpec();
   allColSpecs[2] =  new DataColumnSpecCreator("ID", StringCell.TYPE).createSpec();
   allColSpecs[3] =  new DataColumnSpecCreator("REF", StringCell.TYPE).createSpec();
   allColSpecs[4] =  new DataColumnSpecCreator("ALT", StringCell.TYPE).createSpec();
   allColSpecs[5] =  new DataColumnSpecCreator("QUAL", DoubleCell.TYPE).createSpec();
   allColSpecs[6] =  new DataColumnSpecCreator("FILTER", StringCell.TYPE).createSpec();
   allColSpecs[7] =  new DataColumnSpecCreator("INFO", StringCell.TYPE).createSpec();
   allColSpecs[8] =  new DataColumnSpecCreator("FORMAT", StringCell.TYPE).createSpec();
   allColSpecs[9] = new DataColumnSpecCreator("CALL", StringCell.TYPE).createSpec();
allColSpecs[10] =  new DataColumnSpecCreator("SAMPLE", StringCell.TYPE).createSpec();
   return new DataTableSpec( allColSpecs);
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected BufferedDataTable[] execute(final BufferedDataTable[] inData,
		final ExecutionContext exec) throws Exception {

	// create output table
	BufferedDataContainer container = exec
			.createDataContainer(new DataTableSpec(
					new DataColumnSpec[] { new DataColumnSpecCreator(
							"Column 0", LongCell.TYPE).createSpec() }));

	// add row with count
	container.addRowToTable(new DefaultRow(new RowKey("Row 0"),
			new LongCell[] { new LongCell(TableCellUtils.getRDD(inData[0])
					.count()) }));
	container.close();

	BufferedDataTable out = container.getTable();

	// update viewer
	rddViewer = new RddViewer(out, exec);

	return new BufferedDataTable[] { out };
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
@Override
protected DataTableSpec[] configure(DataTableSpec[] inSpecs)
		throws InvalidSettingsException {
	if(inSpecs==null || inSpecs.length!=1)
		{
		throw new InvalidSettingsException("Expected one tables");
		}
	for(String s:m_numericColumns.getIncludeList())
		{
		if(inSpecs[0].findColumnIndex(s)==-1)
			{
			throw new InvalidSettingsException("Cannot find columns "+s);
			}
		}
	return new DataTableSpec[]{new DataTableSpec(inSpecs[0],createDataTableSpec())};
	}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
private DataTableSpec createDataTableSpec() throws InvalidSettingsException
{
List<String> tags=extractFields();
if(tags.isEmpty()) throw new InvalidSettingsException("No tag was defined");
DataColumnSpec cols[]=new DataColumnSpec[tags.size()*this.m_callColumns.getIncludeList().size()];
DataType t=getDataType();
int n=0;
for(String call:this.m_callColumns.getIncludeList())
	{
	for(int i=0;i< tags.size();++i)
		{
		cols[n++]=new DataColumnSpecCreator(call+":"+tags.get(i),t).createSpec();
		}
	}
return new DataTableSpec(cols);
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
private DataTableSpec createDataTableSpec()
 	{
 	List<DataColumnSpec> specs=new ArrayList<DataColumnSpec>();
if(m_show_chrom.getBooleanValue())
	{
	specs.add(new DataColumnSpecCreator("hg19Snp130.chrom",StringCell.TYPE).createSpec());
	}
if(m_show_chromStart.getBooleanValue())
	{
	specs.add(new DataColumnSpecCreator("hg19Snp130.chromStart",IntCell.TYPE).createSpec());
	}
if(m_show_chromEnd.getBooleanValue())
	{
	specs.add(new DataColumnSpecCreator("hg19Snp130.chromEnd",IntCell.TYPE).createSpec());
	}
if(m_show_name.getBooleanValue())
	{
	specs.add(new DataColumnSpecCreator("hg19Snp130.name",StringCell.TYPE).createSpec());
	}
 	return new DataTableSpec(specs.toArray(new DataColumnSpec[specs.size()]));
 	}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected DataTableSpec[] configure(final DataTableSpec[] inSpecs)
        throws InvalidSettingsException
    {
    if(inSpecs==null || inSpecs.length!=1)
    	{
    	throw new InvalidSettingsException("Expected one table.");
    	}
   
    findColumnIndex(inSpecs[0],m_chromCol,StringCell.TYPE);
    findColumnIndex(inSpecs[0],m_posCol,IntCell.TYPE);
    findColumnIndex(inSpecs[0],m_refCol,StringCell.TYPE);
    findColumnIndex(inSpecs[0],m_altCol,StringCell.TYPE);
    
	return new DataTableSpec[0];
	}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
protected DataTableSpec createDataTableSpec()
 	{
 	List<DataColumnSpec> specs=new ArrayList<DataColumnSpec>();
 	specs.add( new DataColumnSpecCreator("kg.name", StringCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("kg.txStart0", IntCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("kg.txEnd0", IntCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("mutation.types", StringCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("segment.name", StringCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("position.in.cdna0", IntCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("position.in.protein1", IntCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("wild.codon", StringCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("mut.codon", StringCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("wild.AA", StringCell.TYPE).createSpec());
 	specs.add( new DataColumnSpecCreator("mut.AA", StringCell.TYPE).createSpec());
 	if(m_showRNASequence.getBooleanValue())
 		{
 		specs.add( new DataColumnSpecCreator("wild.cDNA", StringCell.TYPE).createSpec());
     	specs.add( new DataColumnSpecCreator("mut.cDNA", StringCell.TYPE).createSpec());
 		}
 	if(m_showProteinSequence.getBooleanValue())
{
specs.add( new DataColumnSpecCreator("wild.prot", StringCell.TYPE).createSpec());
  	specs.add( new DataColumnSpecCreator("mut.prot", StringCell.TYPE).createSpec());
}
 	return new DataTableSpec(specs.toArray(new DataColumnSpec[specs.size()]));
 	}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
private DataTableSpec createSpec(DataTableSpec in)
{
return new DataTableSpec(in,
		new DataTableSpec(new DataColumnSpec[]{
			new DataColumnSpecCreator("label.das.features",StringCell.TYPE).createSpec(),
			new DataColumnSpecCreator("linkUri.das.features",StringCell.TYPE).createSpec(),
			new DataColumnSpecCreator("link.das.features",StringCell.TYPE).createSpec(),
			new DataColumnSpecCreator("start.features",IntCell.TYPE).createSpec(),
			new DataColumnSpecCreator("end.features",IntCell.TYPE).createSpec(),
			new DataColumnSpecCreator("strand.das.features",StringCell.TYPE).createSpec(),
			new DataColumnSpecCreator("type.das.features",StringCell.TYPE).createSpec(),
			new DataColumnSpecCreator("id.das.features",StringCell.TYPE).createSpec()
			}
			)

	);
}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected DataTableSpec[] configure(final DataTableSpec[] inSpecs)
        throws InvalidSettingsException
    {
    if(inSpecs==null || inSpecs.length!=1)
    	{
    	throw new InvalidSettingsException("Expect one input.");
    	}
    DataTableSpec tableSpec=inSpecs[0];
    try
    	{
    	getMutationColumns(tableSpec);
    	}
    catch(Exception err)
    	{
    	throw new InvalidSettingsException("Not a VCF header",err);
    	}
	
	return new DataTableSpec[]{tableSpec,tableSpec};
	}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
@Override
  protected DataTableSpec[] configure(DataTableSpec[] inSpecs)
  		throws InvalidSettingsException {
  	if(inSpecs==null || inSpecs.length!=1)
  		{
  		throw new InvalidSettingsException("Expected one table");
  		}
  	
  	DataTableSpec in=inSpecs[0];
  	int chromCol= in.findColumnIndex(m_chromCol.getColumnName());
if(chromCol==-1) throw new InvalidSettingsException("Cannot find column for chrom");
if(!(in.getColumnSpec(chromCol).getType().equals(IntCell.TYPE) ||
		in.getColumnSpec(chromCol).getType().equals(StringCell.TYPE)
   ))
	{
	throw new InvalidSettingsException("Bad type for chrom:"+in.getColumnSpec(chromCol).getType());
	}
DataTableSpec spec2= ReplacedColumnsTable.createTableSpec(in,
		new DataColumnSpecCreator(in.getColumnSpec(chromCol).getName(),StringCell.TYPE).createSpec(),
		chromCol);
  	
  	return new DataTableSpec[]{spec2};
  	}
 

import org.knime.core.data.DataTableSpec; //导入依赖的package包/类
private DataTableSpec createDataTableSpec(boolean isBed) throws InvalidSettingsException
  	{
  	DataColumnSpec cols[];
  	if(isBed)
   	{
   	cols=new DataColumnSpec[]{
   		new DataColumnSpecCreator(this.m_newColName.getStringValue()+".start",IntCell.TYPE).createSpec(),
   		new DataColumnSpecCreator(this.m_newColName.getStringValue()+".end",IntCell.TYPE).createSpec(),
   		new DataColumnSpecCreator(this.m_newColName.getStringValue()+".rest",StringCell.TYPE).createSpec()
   		};
   	}
else
	{
	cols=new DataColumnSpec[]{
   		new DataColumnSpecCreator(this.m_newColName.getStringValue()+".start",IntCell.TYPE).createSpec(),
   		new DataColumnSpecCreator(this.m_newColName.getStringValue()+".end",IntCell.TYPE).createSpec(),
   		new DataColumnSpecCreator(this.m_newColName.getStringValue()+".value",DoubleCell.TYPE).createSpec()
   		};
	}
  	return new DataTableSpec(cols);
  	}