Java FlowVariable类代码示例

import org.knime.core.node.workflow.FlowVariable; //导入依赖的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.node.workflow.FlowVariable; //导入依赖的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.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Adds a row for the given flow variable.
 *
 * @param var the flow variable definition
 * @return true when the row was added successfully
 */
public boolean addRow(final FlowVariable var) {
    int r = m_model.getRowCount();
    m_model.addRow();
    m_model.setValueAt(var, r, Column.COLUMN);
    String varName = var.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(
            varName, taken, "v_");
    m_model.setValueAt(fieldName, r, Column.JAVA_FIELD);
    Class javaType = TypeProvider.getDefault()
        .getTypeConverter(var.getType()).getPreferredJavaType();
    m_model.setValueAt(javaType, r, Column.JAVA_TYPE);
    return true;
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的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.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Get the field definitions representing input flow variables.
 *
 * @return fields representing input flow variables
 */
public InVarList getInVarFields() {
    InVarList inCols = new InVarList();
    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 FlowVariable) {
            FlowVariable colSpec = (FlowVariable)value;
            InVar inVar = new InVar();
            inVar.setKnimeType(colSpec.getType());
            inVar.setKnimeName(colSpec.getName());
            inVar.setJavaName(
                    (String)m_model.getValueAt(r, Column.JAVA_FIELD));
            inVar.setJavaType((Class)m_model.getValueAt(r,
                    Column.JAVA_TYPE));
            inCols.add(inVar);
        }
    }
    return inCols;
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Validate knime type in the given row.
 * @param row the row to check
 * @return error message if error occurs
 */
private String validateColDataType(final int row) {
    Object value = getValueAt(row, Column.DATA_TYPE);
    if (null == value) {
        return "Please select a value";
    }
    if (value instanceof Type) {
        if (getFieldType(row).equals(FieldType.Column)) {
            return "Please select a data type.";
        }
    } else if (value instanceof DataType) {
        if (getFieldType(row).equals(FieldType.FlowVariable)) {
            return "Please select a flow variable type.";
        }
    } else if (value instanceof String) {
        return "Please select a valid type.";
    }
    // no errors found
    return null;
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Adds a row using the values of the given output variable.
 *
 * @param outVar the output variable definition
 * @return true when the row was added successfully
 */
public boolean addRow(final OutVar outVar) {
    int r = m_model.getRowCount();
    m_model.addRow();
    m_model.setValueAt(outVar.getReplaceExisting(),
            r, Column.REPLACE_EXISTING);
    if (!m_flowVarsOnly) {
        m_model.setValueAt(FieldType.FlowVariable,  r,
                Column.FIELD_TYPE);
    }
    String name = outVar.getKnimeName();
    FlowVariable flowVar = m_flowVars.get(name);
    Object value = null != flowVar ? flowVar : name;
    m_model.setValueAt(value, r, Column.COLUMN);
    m_model.setValueAt(outVar.getKnimeType(), r, Column.DATA_TYPE);
    if (!m_flowVarsOnly) {
        m_model.setValueAt(false, r, Column.IS_COLLECTION);
    }

    m_model.setValueAt(outVar.getJavaName(), r, Column.JAVA_FIELD);
    m_model.setValueAt(outVar.getJavaType(), r, Column.JAVA_TYPE);
    return true;
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Set the flow variables to display.
 * @param flowVars the flow variables.
 */
public void setFlowVariables(final Collection<FlowVariable> flowVars) {
    Collection<FlowVariable> sortedFlowVars = new TreeSet<FlowVariable>(new Comparator<FlowVariable>() {
        @Override
        public int compare(final FlowVariable o1, final FlowVariable o2) {
            return o1.getName().compareTo(o2.getName());
        }
    });
    sortedFlowVars.addAll(flowVars);
    DefaultListModel fvListModel =
        (DefaultListModel)getModel();
    fvListModel.removeAllElements();
    for (FlowVariable v : sortedFlowVars) {
        fvListModel.addElement(v);
    }

}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Create a new repository.
 * @param input the flow variables from the input stack.
 */
public FlowVariableRepository(final Map<String, FlowVariable> input) {
    super();
    m_input = input;
    m_modified = new LinkedHashMap<String, FlowVariable>();
    m_flowVarNames = new LinkedHashSet<String>();
    m_flowVarNames.addAll(input.keySet());
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Get value of a flow variable. The type of the returned object is equal
 * to the given className.
 * @param name the name of the flow variable
 * @param className the type of the returned object
 * @return the value of the flow variable
 */
@SuppressWarnings("rawtypes")
public Object getValueOfType(final String name, final Class className) {
    FlowVariable flowVar = getFlowVariable(name);
    if (null == flowVar) {
        throw new FlowVariableException("The flow variable with name \""
                + name + "\" does not exist.");
    }
    TypeConverter converter =
        TypeProvider.getDefault().getTypeConverter(flowVar.getType());
    return converter.getValue(flowVar, className);
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Returns true when getValueOfType(String, Class) does not throw
 * an TypeException when called with the given flow variable and the given
 * class name.
 * @param name the name of the flow variable
 * @param className the type
 * @return true when flow variable is of type.
 */
@SuppressWarnings("rawtypes")
public boolean isOfType(final String name, final Class className) {
    FlowVariable flowVar = getFlowVariable(name);
    if (null == flowVar) {
        throw new FlowVariableException("The flow variable with name \""
                + name + "\" does not exist.");
    }
    TypeConverter converter =
        TypeProvider.getDefault().getTypeConverter(flowVar.getType());
    return converter.canProvideJavaType(className);
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Add a new or updated flow variable.
 * @param flowVar the flow variable associated with name
 */
public void put(final FlowVariable flowVar) {
    m_modified.put(flowVar.getName(), flowVar);
    // re-add element since natural ordering of flow variables is a stack
    m_flowVarNames.remove(flowVar.getName());
    m_flowVarNames.add(flowVar.getName());
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Validate java type in the given row.
 * @param row the row to check
 * @return error message if error occurs
 */
@SuppressWarnings("rawtypes")
private String validateJavaTypeColumn(final int row) {
    Object value = this.getValueAt(row, Column.JAVA_TYPE);
    if (null == value) {
        return "Please select a value";
    }
    if (!(value instanceof Class)) {
        return "Cannot find class " + value.toString();
    }
    Class javaType = (Class)value;
    Object input = this.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.canProvideJavaType(javaType) ? null
                : "The java type \"" + javaType.getSimpleName()
                  + "\" is not supported.";
    } else if (input instanceof FlowVariable) {
        FlowVariable flowVar = (FlowVariable)input;
        TypeConverter typeConversion =
            TypeProvider.getDefault().getTypeConverter(
                flowVar.getType());
        return typeConversion.canProvideJavaType(javaType) ? null
                : "The java type \"" + javaType.getSimpleName()
                  + "\" is not supported.";
    } else {
        return null;
    }
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Returns the field type for the given column.
 *
 * @param row the row to check
 * @return the field type of the given column
 */
private FieldType getFieldType(final int row) {
    if (m_flowVarsOnly) {
        return FieldType.FlowVariable;
    } else {
        return (FieldType)getValueAt(row, Column.FIELD_TYPE);
    }
}
 

import org.knime.core.node.workflow.FlowVariable; //导入依赖的package包/类
/**
 * Validate field type in the given row.
 * @param row the row to check
 * @return error message if error occurs
 */
private String validateColFieldType(final int row) {
    Object value = getFieldType(row);
    if (null == value) {
        return "Please select a value.";
    }
    return value.equals(FieldType.Column)
        || value.equals(FieldType.FlowVariable) ? null
                : "No valid field type: " + value.toString();
}