Java DataColumnSpec类代码示例

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);
  	}