import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
/**
 * Creates a CellFactory for the class column.
 *
 * @param colName
 *            the name of the class column
 * @return CellFactory for the class column.
 */
private CellFactory createCellFactory(final String colName) {
    return 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(colName, StringCell.TYPE)
                            .createSpec() };
        }

        @Override
        public DataCell[] getCells(final DataRow row) {
            throw new IllegalStateException(
                    new IllegalAccessException("This shouldn't be called"));
        }
    };
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的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.DataColumnSpec; //导入依赖的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.DataColumnSpec; //导入依赖的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.DataColumnSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@SuppressWarnings("rawtypes")
@Override
public Class[] getAllowedJavaTypes(final int row) {
    Object input = getValueAt(row, Column.COLUMN);
    if (input instanceof DataColumnSpec) {
        DataColumnSpec colSpec = (DataColumnSpec)input;
        DataType elemType = colSpec.getType().isCollectionType()
            ? colSpec.getType().getCollectionElementType()
            : colSpec.getType();
        DataValueToJava dvToJava =
            TypeProvider.getDefault().getDataValueToJava(elemType,
                    colSpec.getType().isCollectionType());
        return dvToJava.canProvideJavaTypes();
    } else if (input instanceof FlowVariable) {
        FlowVariable flowVar = (FlowVariable)input;
        TypeConverter typeConversion =
            TypeProvider.getDefault().getTypeConverter(
                flowVar.getType());
        return typeConversion.canProvideJavaTypes();
    } else {
        return new Class[0];
    }
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
private void onSelectionInColumnList(final Object selected) {
    if (selected != null) {
        String enter;
        if (selected instanceof String) {
            enter = (String)selected;
        } else {
            if (null == m_fields) {
                return;
            }
            DataColumnSpec colSpec = (DataColumnSpec)selected;
            enter = m_fields.getFieldReadStatement(colSpec);
        }
        clearSelection();
        if (null != m_snippet) {
            m_snippet.replaceSelection(enter);
            m_snippet.requestFocus();
        }
    }
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
/**
 * Adds a row for the given input column.
 *
 * @param colSpec the input column
 * @return true when the row was added successfully
 */
public boolean addRow(final DataColumnSpec colSpec) {
    int r = m_model.getRowCount();
    m_model.addRow();

    m_model.setValueAt(colSpec, r, Column.COLUMN);
    String colName = colSpec.getName();
    Set<String> taken = new HashSet<String>();
    for (int i = 0; i < m_model.getRowCount(); i++) {
        taken.add((String)m_model.getValueAt(i, Column.JAVA_FIELD));
    }
    String fieldName = FieldsTableUtil.createUniqueJavaIdentifier(
            colName, taken, "c_");
    m_model.setValueAt(fieldName, r, Column.JAVA_FIELD);
    DataType elemType = colSpec.getType().isCollectionType()
        ? colSpec.getType().getCollectionElementType()
        : colSpec.getType();
    DataValueToJava dvToJava =
        TypeProvider.getDefault().getDataValueToJava(elemType,
                colSpec.getType().isCollectionType());
    Class javaType = dvToJava.getPreferredJavaType();
    m_model.setValueAt(javaType, r, Column.JAVA_TYPE);
    return true;
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
/** Create cell editor for for the input columns / flow variables. */
private TableCellEditor createInputCellEditor() {
    JComboBox comboBox = new JComboBox();
    comboBox.setRenderer(new InputListCellRenderer());
    if (null != m_spec) {
        for (DataColumnSpec colSpec : m_spec) {
            comboBox.addItem(colSpec);
        }
    }
    if (null != m_flowVars) {
        for (FlowVariable flowVar : m_flowVars.values()) {
            comboBox.addItem(flowVar);
        }
    }
    DefaultCellEditor editor =  new DefaultCellEditor(comboBox);
    editor.setClickCountToStart(2);
    return editor;
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
/**
 * Get the field definitions representing input columns.
 *
 * @return fields representing input columns.
 */
public InColList getInColFields() {
    InColList inCols = new InColList();
    for (int r = 0; r < m_model.getRowCount(); r++) {
        if (!m_model.validateValues(r)) {
            // there are errors in this row
            continue;
        }
        Object value = m_model.getValueAt(r, Column.COLUMN);
        if (value instanceof DataColumnSpec) {
            DataColumnSpec colSpec = (DataColumnSpec)value;
            InCol inCol = new InCol();
            inCol.setKnimeType(colSpec.getType());
            inCol.setKnimeName(colSpec.getName());
            inCol.setJavaName(
                    (String)m_model.getValueAt(r, Column.JAVA_FIELD));
            Object javaTypeObject = m_model.getValueAt(r,
                    Column.JAVA_TYPE);
            if (javaTypeObject instanceof Class) {
                inCol.setJavaType((Class)javaTypeObject);
            }
            inCols.add(inCol);
        }
    }
    return inCols;
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Component getListCellRendererComponent(final JList list,
        final Object value, final int index,
        final boolean isSelected, final boolean cellHasFocus) {
    // reset values which maybe changed by previous calls of this method
    setForeground(list.getForeground());
    setBackground(list.getBackground());
    // let super class do the first step
    super.getListCellRendererComponent(list, value, index, isSelected,
            cellHasFocus);
    if (value instanceof DataColumnSpec) {
        DataColumnSpec col = (DataColumnSpec)value;
        setIcon(col.getType().getIcon());
        setText(col.getName());
        setToolTipText(null);
    } else if (null == value || value instanceof String) {
        setIcon(null);
        setBackground(reddishBackground());
        setToolTipText("Please select an input.");
    }
    return this;
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
/**
 * Adds a row using the values of the given output column.
 *
 * @param outCol the output column definition
 * @return true when the row was added successfully
 */
public boolean addRow(final OutCol outCol) {
    int r = m_model.getRowCount();
    m_model.addRow();
    m_model.setValueAt(outCol.getReplaceExisting(),
            r, Column.REPLACE_EXISTING);
    m_model.setValueAt(FieldType.Column, r, Column.FIELD_TYPE);

    String colName = outCol.getKnimeName();
    DataColumnSpec colSpec = m_spec.getColumnSpec(colName);
    Object value = null != colSpec ? colSpec : colName;
    m_model.setValueAt(value, r, Column.COLUMN);
    DataType type = outCol.getKnimeType();
    boolean isCollection = type.isCollectionType();
    m_model.setValueAt(
            isCollection ? type.getCollectionElementType() : type,
            r, Column.DATA_TYPE);
    m_model.setValueAt(isCollection, r, Column.IS_COLLECTION);
    m_model.setValueAt(outCol.getJavaName(), r, Column.JAVA_FIELD);
    m_model.setValueAt(outCol.getJavaType(), r, Column.JAVA_TYPE);
    return true;
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的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.DataColumnSpec; //导入依赖的package包/类
protected MediaWikiExistsNodeDialog()
{
SettingsModelString settings=new SettingsModelString(MediaWikiExistsNodeModel.MW_API_PROPERTY,MediaWikiExistsNodeModel.MW_API_DEFAULT);
addDialogComponent(new DialogComponentString(settings, "Mediawiki API URI",true,20));

SettingsModelColumnName set=new SettingsModelColumnName(MediaWikiExistsNodeModel.COL_PROPERTY, MediaWikiExistsNodeModel.COL_DEFAULT);
addDialogComponent(new DialogComponentColumnNameSelection(set, "Column", 0,new ColumnFilter()
	{
	@Override
	public String allFilteredMsg() {
		return "all columns excluded";
		}
	@Override
	public boolean includeColumn(DataColumnSpec colSpec) {
			return true;
			}
	}));
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的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.DataColumnSpec; //导入依赖的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);
  	}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
private DataTableSpec createDataSpec()
{
String prefix=this.m_prefix.getStringValue()+".";
return new DataTableSpec(
	new DataColumnSpec[]{	
		new DataColumnSpecCreator(prefix+"chrom", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator(prefix+"chromStart", IntCell.TYPE).createSpec(),
		new DataColumnSpecCreator(prefix+"chromEnd", IntCell.TYPE).createSpec(),
		new DataColumnSpecCreator(prefix+"InOut", BooleanCell.TYPE).createSpec(),
		new DataColumnSpecCreator(prefix+"Count", IntCell.TYPE).createSpec(),
		new DataColumnSpecCreator(prefix+"Min", DoubleCell.TYPE).createSpec(),
		new DataColumnSpecCreator(prefix+"Max", DoubleCell.TYPE).createSpec(),
		new DataColumnSpecCreator(prefix+"Mean", DoubleCell.TYPE).createSpec()
		}
	);
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的package包/类
protected DataTableSpec createDataTableSpec()
{
DataColumnSpec cols[]=new DataColumnSpec[]{
		new DataColumnSpecCreator("DB", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("ID", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Splice", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Symbol", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Taxon", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Qualifier", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("GO ID", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("GO Name", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Reference", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Evidence", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("With", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Aspect", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Date", StringCell.TYPE).createSpec(),
		new DataColumnSpecCreator("Source", StringCell.TYPE).createSpec()
		};
return new DataTableSpec(cols);
}
 

import org.knime.core.data.DataColumnSpec; //导入依赖的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.DataColumnSpec; //导入依赖的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.DataColumnSpec; //导入依赖的package包/类
private DataColumnSpec[] createVcfDataColumnSpec()
{
DataColumnSpec[] allColSpecs = new DataColumnSpec[11];
allColSpecs[0] =  new DataColumnSpecCreator("SAMPLE", StringCell.TYPE).createSpec();
   allColSpecs[1] =  new DataColumnSpecCreator("CHROM", StringCell.TYPE).createSpec();
   allColSpecs[2] =  new DataColumnSpecCreator("POS", IntCell.TYPE).createSpec();
   allColSpecs[3] =  new DataColumnSpecCreator("ID", StringCell.TYPE).createSpec();
   allColSpecs[4] =  new DataColumnSpecCreator("REF", StringCell.TYPE).createSpec();
   allColSpecs[5] =  new DataColumnSpecCreator("ALT", StringCell.TYPE).createSpec();
   allColSpecs[6] =  new DataColumnSpecCreator("QUAL", DoubleCell.TYPE).createSpec();
   allColSpecs[7] =  new DataColumnSpecCreator("FILTER", StringCell.TYPE).createSpec();
   allColSpecs[8] =  new DataColumnSpecCreator("INFO", StringCell.TYPE).createSpec();
   allColSpecs[9] =  new DataColumnSpecCreator("FORMAT", StringCell.TYPE).createSpec();
   allColSpecs[10] = new DataColumnSpecCreator("CALL", StringCell.TYPE).createSpec();
   return allColSpecs;
}