import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
@Override
public void mapDataSeriesRowsToTableColumn(CyNetwork network, Class<? extends CyIdentifiable> targetClass, String columnName,
		DataSeries<?, ?> ds) {
	
	Map<Class<? extends CyIdentifiable>, Map<String, DataSeries<?, ?>>> networkMappings = mappings.get(network);
	if (networkMappings == null)
	{
		networkMappings = new HashMap<>();
		mappings.put(network, networkMappings);
	}
	
	Map<String, DataSeries<?, ?>> localMap = networkMappings.get(targetClass);
	if(localMap == null)
	{
		localMap = new HashMap<>();
		networkMappings.put(targetClass, localMap);
	}
	
	if(localMap.containsKey(columnName))
	{
		logger.warn("Remapping column '" + columnName +"' for network " + Utils.getNetworkName(network) + " class " + targetClass.getSimpleName());			
	}
	localMap.put(columnName, ds);
	
	fireEvent(new DataSeriesMappingEvent(this, EventType.MAPPING_ADDED, Collections.singletonList(new MappingDescriptor<DataSeries<?,?>>(network, targetClass, columnName, ds))));
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
@Override
public <T extends DataSeries<?, ?>> T getMappedDataSeries(CyNetwork network, Class<? extends CyIdentifiable> targetClass,
		String columnName, Class<T> seriesClass) {
	DataSeries<?, ?> series = getMappedDataSeries(network, targetClass, columnName);
	if(series == null)
	{
		return null;
	}
	else if(seriesClass.isAssignableFrom(series.getClass()))
	{
		@SuppressWarnings("unchecked")
		T castSeries = (T)series;
		return (T)castSeries;
	}
	else
	{
		throw new DataSeriesException("Mapped data series " + series.getName() + " does not have expected class (" + seriesClass.getName() + ")");
	}
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public <T extends DataSeries<?, ?>> Map<String, T> getAllMappings(CyNetwork network, Class<? extends CyIdentifiable> targetClass,
		Class<T> dataSeriesClass) {
	Map<Class<? extends CyIdentifiable>, Map<String, DataSeries<?, ?>>> networkMap = mappings.get(network);
	if(networkMap == null)
	{
		return Collections.EMPTY_MAP;
	}
	Map<String, DataSeries<?, ?>> localMap = networkMap.get(targetClass);
	if(localMap == null)
	{
		return Collections.EMPTY_MAP;
	}
	return  (Map<String, T>)Maps.filterEntries(localMap, e -> dataSeriesClass.isAssignableFrom(e.getValue().getClass()));
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
private void updateEdgeWeightColumnList() {
    weightColumnModel.removeAllElements();

    if (session == null) {
        return;
    }

    CyNetworkView view = session.getNetworkView();
    CyNetwork model = view.getModel();
    CyTable table = model.getDefaultEdgeTable();
    table.getColumns()
         .stream()
         .filter(c -> !CyIdentifiable.SUID.equals(c.getName()) && Number.class.isAssignableFrom(c.getType()))
         .map(c -> c.getName())
         .sorted(String.CASE_INSENSITIVE_ORDER)
         .forEach(name -> weightColumnModel.addElement(name));

    weightColumn.setSelectedItem(session.getWeightColumn());

    if (weightColumn.getSelectedIndex() == -1 && weightColumnModel.getSize() > 0) {
        weightColumn.setSelectedIndex(0);
    }
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
public LongObjectMap<SafeSession> loadFromSession(CySession cySession) throws IOException {

        CyTable dataTable = cySession.getTables()
                                     .stream()
                                     .map(metadata -> metadata.getTable())
                                     .filter(table -> DATA_TABLE_TITLE.equals(table.getTitle()))
                                     .findFirst()
                                     .orElse(null);

        LongObjectMap<SafeSession> sessions = new LongObjectHashMap<>();
        if (dataTable == null) {
            return sessions;
        }

        for (CyRow row : dataTable.getAllRows()) {
            String json = row.get(SAFE_DATA_COLUMN, String.class);
            SafeSession session = parseSession(json);

            Long oldSuid = row.get(CyIdentifiable.SUID, Long.class);
            CyNetworkView view = cySession.getObject(oldSuid, CyNetworkView.class);
            session.setNetworkView(view);
            sessions.put(view.getSUID(), session);
        }
        return sessions;
    }
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的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.CyIdentifiable; //导入依赖的package包/类
@Override
public void serialize(final CyNetworkView networkView, JsonGenerator jgen, SerializerProvider provider)
		throws IOException, JsonProcessingException {

	final CyNetwork network = networkView.getModel();
	Collection<CyRow> root = network.getDefaultNodeTable().getMatchingRows(CyNetwork.SELECTED, true);

	if (root.size() != 1) {
		throw new IllegalStateException("You need to select one node as the root for this tree.");
	}

	CyRow rootNodeRow = root.iterator().next();
	final CyNode rootNode = network.getNode(rootNodeRow.get(CyIdentifiable.SUID, Long.class));
	if (rootNode == null) {
		throw new IllegalStateException("Could not find the root for this tree.");
	}

	jgen.useDefaultPrettyPrinter();

	expanded = new HashSet<CyNode>();
	getChildren(network, rootNode, jgen);
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的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.CyIdentifiable; //导入依赖的package包/类
private void updateMapRowNamesWithColumn(Class<? extends CyIdentifiable> targetClass)
{
	showColumnsForClass(String.class, mapRowNamesWithColumn, targetClass);
	if(mapRowNamesWithColumn.getPossibleValues().contains("name") && mapRowNamesWithColumn.getSelectedValue() == null)
	{
		mapRowNamesWithColumn.setSelectedValue("name");
	}
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的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.CyIdentifiable; //导入依赖的package包/类
public ChartSource(CyNetwork network, Class<? extends CyIdentifiable> targetClass, CyRow row) {
	super();
	this.network = network;
	this.targetClass = targetClass;
	this.row = row;
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
protected void unmapTableColumnInternal(CyNetwork network, Class<? extends CyIdentifiable> targetClass, String columnName, boolean fireEvent) {
	Map<Class<? extends CyIdentifiable>, Map<String, DataSeries<?, ?>>> networkMappings = mappings.get(network);
	if (networkMappings == null)
	{
		logger.warn("No mappings for network " + Utils.getNetworkName(network)  + " exists. Cannot remove mapping for '" + columnName + "'");
		return;			
	}
	
	Map<String, DataSeries<?, ?>> localMap = networkMappings.get(targetClass);
	if(localMap == null)
	{
		logger.warn("No mappings for " + targetClass.getSimpleName() + " exists. Cannot remove mapping for '" + columnName + "'");
		return;
	}
	if(!localMap.containsKey(columnName))
	{
		logger.warn("Mappings for column '" + columnName + "' for network " + Utils.getNetworkName(network)  + " and class " + targetClass.getSimpleName() + " does not exist, cannot remove.");
		return;			
	}
	DataSeries<?,?> ds = localMap.get(columnName); //store for event
	localMap.remove(columnName);

	if(fireEvent)
	{
		fireEvent(new DataSeriesMappingEvent(this, EventType.MAPPING_REMOVED, Collections.singletonList(new MappingDescriptor<DataSeries<?,?>>(network, targetClass, columnName, ds))));
	}		
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
@Override
public boolean isMappingsEmpty() {
	for(Map<Class<? extends CyIdentifiable>, Map<String, DataSeries<?, ?>>> networkMapping : mappings.values())
	{
		for(Map<String, DataSeries<?,?>> classMapping: networkMapping.values())
		{
			if(!classMapping.isEmpty())
			{
				return false;
			}
		}
	}
	return true;
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
@Override
public Collection<Class<? extends CyIdentifiable>> getTargetsWithMappedDataSeries(CyNetwork network) {
	Map<Class<? extends CyIdentifiable>, Map<String, DataSeries<?, ?>>> networkMapping = mappings.get(network);
	if(networkMapping == null)
	{
		return Collections.EMPTY_LIST;
	}
	return networkMapping.keySet();
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
public MappingDescriptor(CyNetwork network, Class<? extends CyIdentifiable> targetClass, String columnName,
		T dataSeries) {
	super();
	this.network = network;
	this.targetClass = targetClass;
	this.columnName = columnName;
	this.dataSeries = dataSeries;
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
private void updateExistingColumnForMapping(Class<? extends CyIdentifiable> targetClass)
{
	showColumnsForClass(DataSeriesMappingManager.MAPPING_COLUMN_CLASS, existingColumnForMapping, targetClass);		
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
public TargetClassInfo(String displayName, Class<? extends CyIdentifiable> targetClass) {
	super();
	this.displayName = displayName;
	this.targetClass = targetClass;
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
public Class<? extends CyIdentifiable> getTargetClass() {
	return targetClass;
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
@Override
public void unmapTableColumn(CyNetwork network, Class<? extends CyIdentifiable> targetClass, String columnName) {		
	unmapTableColumnInternal(network, targetClass, columnName, true);
}
 

import org.cytoscape.model.CyIdentifiable; //导入依赖的package包/类
@Override
public CyTable getMappingTable(CyNetwork network, Class<? extends CyIdentifiable> targetClass) {
	return network.getTable(targetClass, CyNetwork.LOCAL_ATTRS);
}