import org.cytoscape.model.CyColumn; //导入依赖的package包/类
public static void checkSafeColumns(CyTable table) {
    CyColumn column = table.getColumn(StyleFactory.HIGHLIGHT_COLUMN);
    if (column == null) {
        table.createColumn(StyleFactory.HIGHLIGHT_COLUMN, Double.class, false, 0D);
    }

    column = table.getColumn(StyleFactory.COLOR_COLUMN);
    if (column == null) {
        table.createColumn(StyleFactory.COLOR_COLUMN, String.class, false, null);
    }

    column = table.getColumn(StyleFactory.BRIGHTNESSS_COLUMN);
    if (column == null) {
        table.createColumn(StyleFactory.BRIGHTNESSS_COLUMN, Double.class, false, 0D);
    }
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
public static void set(CyNetwork network, CyIdentifiable entry, String tableName, String name, Object value, Class<?> type) {
	CyRow row = network.getRow(entry, tableName);
	CyTable table = row.getTable();
	CyColumn column = table.getColumn(name);
	if (value != null) {
		if (column == null) {
			if (value instanceof List) {
				table.createListColumn(name, type, false);
			}
			else if (value instanceof Collection) {
				throw new IllegalArgumentException("Arrt. values collection is not a List: "
						+ value.getClass().getSimpleName());
			}
			else {
				table.createColumn(name, type, false);
			}
		}
		row.set(name, value);
	}
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
/**
 * Adds a column to the current network settings.
 * 
 * @param network
 * @param addedColumnName
 */
public void addColumnName(CyNetwork network, String addedColumnName) {
	CyColumn c = network.getDefaultNodeTable().getColumn(addedColumnName);
	if (c == null)
		return;
	
	if (existsColumn(addedColumnName) && c != null)
		return;

	columnNamesSet.add(addedColumnName);
	columnNames.add(addedColumnName);
	int i = columnNames.size() - 1;

	if (c.getListElementType() == String.class) {
		allGroupColumns.add(i);
		allGroupColumnSizes.add(Constants.CATEGORY_MAX_SIZE);
	} else if (c.getType() == String.class) {
		allStringColumns.add(i);
	} else if (c.getType() == Double.class) {
		allDoubleColumns.add(i);
	}
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
public static void set(CyNetwork network, CyIdentifiable entry, String tableName, String name, Object value, Class<?> type) {
	CyRow row = network.getRow(entry, tableName);
	CyTable table = row.getTable();
	CyColumn column = table.getColumn(name);
	if (value != null) {
		if (column == null) {
			if (value instanceof List) {
				table.createListColumn(name, type, false);
			}
			else if (value instanceof Collection) {
				throw new IllegalArgumentException("Attribute value is a Collection and not List: "
						+ value.getClass().getSimpleName());
			}
			else {
				table.createColumn(name, type, false);
			}
		}
		row.set(name, value);
	}
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private ListSingleSelection<String> getTargetColumns() 
{
	final CyTable table = network.getTable(CyNode.class, CyNetwork.DEFAULT_ATTRS);
	final List<String> colNames = new ArrayList<String>();
	
	for (final CyColumn col : table.getColumns()) {
		// Exclude list, numerical, boolean type columns
		if (String.class.isAssignableFrom(col.getType())) {
			colNames.add(col.getName());
		}
	}

	ListSingleSelection<String> toReturn = 
			new ListSingleSelection<String>(colNames);
	
	if(colNames.contains("UNIPROT"))
		toReturn.setSelectedValue("UNIPROT");
	else if(colNames.contains("GENE SYMBOL"))
		toReturn.setSelectedValue("GENE SYMBOL");
	else if(colNames.contains("URI"))
		toReturn.setSelectedValue("URI");
	else if(colNames.contains(CyRootNetwork.SHARED_NAME))
		toReturn.setSelectedValue(CyRootNetwork.SHARED_NAME); //less desired
	
	return toReturn;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private void showColumnsForClass(Class<?> columnType, ListSingleSelection<String> selection, Class<? extends CyIdentifiable> targetClass)
{
	CyNetwork network = targetNetwork.getSelectedValue();
	List<CyColumn> candidateColumns = new ArrayList<>(mappingManager.getMappingTable(network, targetClass).getColumns());
	List<String> filteredCandidateColumnsNames = candidateColumns.stream()
			.filter(col -> col.getType() == columnType && !col.isPrimaryKey())
			.map(col -> col.getName())
			.collect(Collectors.toList());
	
	filteredCandidateColumnsNames.sort(new AlphanumComparator<>());
	
	selection.setPossibleValues(filteredCandidateColumnsNames);
	
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
static boolean isStringColumn(CyColumn column) {
    Class<?> type = column.getType();
    if (type.equals(String.class)) {
        return true;
    }
    if (type.equals(List.class) && column.getListElementType()
                                         .equals(String.class)) {
        return true;
    }
    return false;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private void checkColumn(CyTable table,
                         String name,
                         Class<?> type) {
    CyColumn column = table.getColumn(name);
    if (column == null) {
        table.createColumn(name, type, false);
    }
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
public static List<String> getColumnsOfType(CyNetwork network, Class<?> type, boolean node, boolean addNone, boolean allowList) {
	List<String> columns = new LinkedList<>();
	
	CyTable table;
	if(node)
		table = network.getDefaultNodeTable();
	else 
		table = network.getDefaultEdgeTable();
	
	for(CyColumn column : table.getColumns()) {
		if(column.getName().equalsIgnoreCase("suid")) {
			continue;
		}
		
		if(type.isAssignableFrom(column.getType())) {
			columns.add(column.getName());
		}
		else if(allowList && List.class.equals(column.getType()) && type.isAssignableFrom(column.getListElementType())) {
			columns.add(column.getName());
		}
	}
	
	columns.sort(Comparator.naturalOrder());
	if(addNone) {
		columns.add(0, NONE);
	}
	return columns;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private String getLabelColumn() {
	Collection<CyColumn> columns = networkView.getModel().getDefaultNodeTable().getColumns();
	for(CyColumn column : columns) {
		String name = column.getName();
		if(name.endsWith("GS_DESCR")) {
			return name;
		}
	}
	return CyNetwork.NAME;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private void aggregateAttributes(CyNetwork originNetwork, SummaryNetwork summaryNetwork) {
	CyTable originNodeTable = originNetwork.getDefaultNodeTable();
	
	CyTable summaryNodeTable = summaryNetwork.network.getDefaultNodeTable();
	summaryNodeTable.createColumn("cluster node count", Integer.class, false);
	
	List<String> columnsToAggregate = new ArrayList<>();
	for(CyColumn column : originNodeTable.getColumns()) {
		String name = column.getName();
		if(summaryNodeTable.getColumn(name) == null) {
			columnsToAggregate.add(name);
			Class<?> listElementType = column.getListElementType();
			if(listElementType == null) {
				summaryNodeTable.createColumn(name, column.getType(), false);
			}
			else {
				summaryNodeTable.createListColumn(name, listElementType, false);
			}
		}
	}
	
	for(SummaryCluster cluster : summaryNetwork.getClusters()) {
		CyNode summaryNode = summaryNetwork.getNodeFor(cluster);
		CyRow row = summaryNodeTable.getRow(summaryNode.getSUID());
		
		row.set("name", cluster.getLabel());
		row.set("cluster node count", cluster.getNodes().size());
		
		for(String columnName : columnsToAggregate) {
			Object result = aggregate(originNetwork, cluster, columnName);
			row.set(columnName, result);
		}
	}
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
@Override
public void run(TaskMonitor taskMonitor) {
	taskMonitor.setTitle(BuildProperties.APP_NAME);
	taskMonitor.setStatusMessage("Calculating clusterMaker edgeCutOff attribute.");
	
	CyTable table = network.getDefaultEdgeTable();
	CyColumn column = table.getColumn(edgeAttribute);
	
	double min = Double.MAX_VALUE;
	boolean updated = false;
	
	if(column != null) {
		Class<?> type = column.getType();
		if(Number.class.isAssignableFrom(type)) {
			for(CyRow row : table.getAllRows()) {
				Number value = (Number) row.get(edgeAttribute, type);
				if(value != null) {
					double doubleValue = value.doubleValue();
					if(Double.isFinite(doubleValue)) {
						min = Math.min(doubleValue, min);
						updated = true;
					}
				}
			}
		}
	}
	
	result = updated ? min : null;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private void addVirtualColumn (CyColumn col, CyTable subTable){
	VirtualColumnInfo colInfo = col.getVirtualColumnInfo();
	CyColumn checkCol= subTable.getColumn(col.getName());
	
	if (checkCol == null)
		subTable.addVirtualColumn(col.getName(), colInfo.getSourceColumn(), colInfo.getSourceTable(), 
				colInfo.getTargetJoinKey(), col.isImmutable());

	else
		if (!checkCol.getVirtualColumnInfo().isVirtual() ||
				!checkCol.getVirtualColumnInfo().getSourceTable().equals(colInfo.getSourceTable()) ||
				!checkCol.getVirtualColumnInfo().getSourceColumn().equals(colInfo.getSourceColumn()))
			subTable.addVirtualColumn(col.getName(), colInfo.getSourceColumn(), colInfo.getSourceTable(), 
					colInfo.getTargetJoinKey(), col.isImmutable());
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
public static CyColumn getOrCreateColumnByPrototype(String name, Object prototype,
                                    boolean immutable, CyTable table) {
    if (name == null) throw new NullPointerException("name cannot be null");
    if (table == null) throw new NullPointerException("table cannot be null");

    Class<?> type = (prototype == null) ? String.class : prototype.getClass();
    if (!SUPPORTED_TYPES.contains(type)) {
        type = String.class;
    }

    return getOrCreateColumn(name, type, immutable, table);
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
public static CyColumn getOrCreateListColumn(String name, Class<?> type, boolean immutable, CyTable table) {
    if (name == null) throw new NullPointerException("name cannot be null");
    if (type == null) throw new NullPointerException("type cannot be null");
    if (table == null) throw new NullPointerException("table cannot be null");

    CyColumn column = table.getColumn(name);
    if (column == null) {
        table.createListColumn(name, type, immutable);
        column = table.getColumn(name);
    }
    return column;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private List<String> getEdgeColumnNames() {
	List<String> names = new ArrayList<String>();
	names.add("- Select Column -");
	for (CyNetwork network: CyActivator.networkManager.getNetworkSet()) {
		for (CyColumn col:  network.getDefaultEdgeTable().getColumns()) {
			if (!names.contains(col.getName()) &&  (!col.getName().equals("SUID")) &&
					((col.getType() == Double.class) || (col.getType() == Integer.class) || (col.getType() == Long.class))) 
				names.add(col.getName());
		}
	}
	return names;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private Double minScoreThreshold() {
	String proteinGraphName = proteinGraph.getSelectedItem().toString();
	if (proteinGraphName.equals(" - Select Network - ")) {
		JOptionPane.showMessageDialog(this, "Please select a protein graph under 'Search'");
	} else {
		CyNetwork nw = null;
		for (CyNetwork network: CyActivator.networkManager.getNetworkSet()) {
			if (network.getRow(network).get(CyNetwork.NAME, String.class).equals(proteinGraphName)) {
				nw = network; 
				break;
			}
		}
		
		CyTable nodeTable = nw.getDefaultEdgeTable();
		if(nodeTable.getColumn("weight") != null) {
			// Network has weight column
			CyColumn column = nodeTable.getColumn("weight");
			List<Double> values = column.getValues(Double.class);
			Double avgWeight = 0.0;
			for (Double value : values) {
				avgWeight += value;
			}
			avgWeight = avgWeight / values.size();
			return avgWeight * Integer.valueOf(minSize.getText()) / 10;
		} else {
			// No weight column
			return 0.5;
		}
		
	}
	return -1.0;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
/**
 * Return zero or more Ensembl gene ids from the specified Ensembl gene id column for the specified node.
 *
 * @param node node
 * @param network network
 * @param ensemblGeneIdColumn Ensembl gene id column
 * @return zero or more Ensembl gene ids from the specified Ensembl gene id column for the specified node
 */
static Iterable<String> ensemblGeneIds(final CyNode node, final CyNetwork network, final String ensemblGeneIdColumn)
{
    CyTable table = network.getDefaultNodeTable();
    CyRow row = table.getRow(node.getSUID());
    CyColumn column = table.getColumn(ensemblGeneIdColumn);

    if (column != null)
    {
        Class<?> columnClass = column.getType();
        if (String.class.equals(columnClass))
        {
            String ensemblGeneId = row.get(ensemblGeneIdColumn, String.class);
            if (ensemblGeneId != null)
            {
                return ImmutableList.of(ensemblGeneId);
            }
        }
        else if (columnClass.equals(List.class))
        {
            Class<?> listClass = column.getListElementType();
            if (String.class.equals(listClass))
            {
                return row.getList(ensemblGeneIdColumn, String.class);
            }
        }
    }
    return Collections.<String>emptyList();
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
/**
 * Return the maximum count value in the specified column in the specified network.
 *
 * @param network network
 * @param columnName column name
 * @return the maximum count value in the specified column in the specified network
 */
static int maxCount(final CyNetwork network, final String columnName)
{
    CyTable table = network.getDefaultNodeTable();
    CyColumn column = table.getColumn(columnName);
    int max = 0;
    for (Integer value : column.getValues(Integer.class))
    {
        if (value != null && value > max)
        {
            max = value;
        }
    }
    return max;
}
 

import org.cytoscape.model.CyColumn; //导入依赖的package包/类
private static String detectImmutableProblem(String key, CyTable table, Class<?> valueClass, Class<?> colClass){
	
	CyColumn col = table.getColumn(key);
	
	String newKey = key; // trying to make this less confusing with the extra variables

	if(col.isImmutable() && !matchingValues(valueClass,colClass)){
		newKey = key + "_cannot_change_original";
		
		// we had this problem before and fixed it, now use the fixed column instead of the previous one!
		if(table.getColumn(newKey) == null){
			if(table.getColumn(key).getListElementType() != null){
				table.createListColumn(newKey,table.getColumn(key).getListElementType() , false);
				
			} else {
				table.createColumn(newKey, table.getColumn(key).getType(), false);
			}
			
			// populate the new column!
			List<CyRow> rows = table.getAllRows();
			for(CyRow row : rows){
				if(row.isSet(key)){
					table.getRow(row.get("SUID", Long.class)).set(newKey, row.getRaw(key));
				}
			}
			
		}
	}
	
	return newKey;
	
}