Java CyRow类代码示例

import org.cytoscape.model.CyRow; //导入依赖的package包/类
void serializeSession(CyTable dataTable,
                      SafeSession session) {
    CyNetworkView networkView = session.getNetworkView();
    CyNetwork network = networkView.getModel();
    CyTable networkTable = network.getDefaultNetworkTable();
    CyRow row = networkTable.getRow(network.getSUID());

    checkColumn(networkTable, DATA_TABLE_COLUMN, Long.class);
    Long suid = dataTable.getSUID();
    row.set(DATA_TABLE_COLUMN, suid);

    CyRow viewRow = dataTable.getRow(networkView.getSUID());
    try (StringWriter writer = new StringWriter()) {
        toJson(session, writer);
        String json = writer.toString();
        viewRow.set(SAFE_DATA_COLUMN, json);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

import org.cytoscape.model.CyRow; //导入依赖的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.CyRow; //导入依赖的package包/类
private void collapse() {
	if(!cluster.isCollapsed()) {
		modelManager.ignore(VIEW_CHANGE, SELECTION).whileRunning(() -> {
			CyNetwork network = cluster.getNetwork();
			List<CyNode> nodes = new ArrayList<>(cluster.getNodes());
			
			CyGroup group = groupFactory.createGroup(network, nodes, null, true);
			
			CyRow groupRow = ((CySubNetwork)network).getRootNetwork().getRow(group.getGroupNode(), CyRootNetwork.SHARED_ATTRS);
	 		groupRow.set(CyRootNetwork.SHARED_NAME, cluster.getLabel());
	 		
			group.collapse(network);
			
			if(overrideAttribute) {
				maybeCreateAnotherAttributeForName(network, groupRow);
			}
		});
	}
}
 

import org.cytoscape.model.CyRow; //导入依赖的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.CyRow; //导入依赖的package包/类
public void selectEdges(String n1, String n2) {
    CyTable nodeTable = network.getDefaultNodeTable();
    List<CyEdge> edges = network.getEdgeList();
    
    for(CyRow row : nodeTable.getAllRows()) {
        row.set(CyNetwork.SELECTED, false);
    }
    
    for(CyEdge edge : edges) {
        if((network.getRow(edge.getSource()).get(CyNetwork.NAME, String.class).equalsIgnoreCase(n1) && network.getRow(edge.getTarget()).get(CyNetwork.NAME, String.class).equalsIgnoreCase(n2)) ||
                (network.getRow(edge.getSource()).get(CyNetwork.NAME, String.class).equalsIgnoreCase(n2) && network.getRow(edge.getTarget()).get(CyNetwork.NAME, String.class).equalsIgnoreCase(n1))) {
            network.getRow(edge).set(CyNetwork.SELECTED, true);
        }
        else{
            network.getRow(edge).set(CyNetwork.SELECTED, false);
        }
    }
    
    if (networkView != null) {
        networkView.updateView();
        applicationManager.setCurrentNetworkView(networkView);
    }
}
 

import org.cytoscape.model.CyRow; //导入依赖的package包/类
public static Set<CyNode> getNodesWithValue(
		final CyNetwork net, final CyTable table,
		final String colname, final Object value)
{
	final Collection<CyRow> matchingRows = table.getMatchingRows(colname, value);
	final Set<CyNode> nodes = new HashSet<CyNode>();
	final String primaryKeyColname = table.getPrimaryKey().getName();
	for (final CyRow row : matchingRows)
	{
		final Long nodeId = row.get(primaryKeyColname, Long.class);
		if (nodeId == null)
			continue;
		final CyNode node = net.getNode(nodeId);
		if (node == null)
			continue;
		nodes.add(node);
	}
	return nodes;
}
 

import org.cytoscape.model.CyRow; //导入依赖的package包/类
public static Set<CyEdge> getEdgeWithValue(
		final CyNetwork net, final CyTable table,
		final String colname, final Object value)
{
	final Collection<CyRow> matchingRows = table.getMatchingRows(colname, value);
	final Set<CyEdge> edges = new HashSet<CyEdge>();
	final String primaryKeyColname = table.getPrimaryKey().getName();
	for (final CyRow row : matchingRows)
	{
		final Long edgeId = row.get(primaryKeyColname, Long.class);
		if (edgeId == null)
			continue;
		final CyEdge edge = net.getEdge(edgeId);
		if (edge == null)
			continue;
		edges.add(edge);
	}
	return edges;
}
 

import org.cytoscape.model.CyRow; //导入依赖的package包/类
@Override
public void serialize(final CyRow row, JsonGenerator jgen, SerializerProvider provider) throws IOException,
		JsonProcessingException {

	final CyTable table = row.getTable();
	final Map<String, Object> values = row.getAllValues();

	for (final String columnName : values.keySet()) {
		final Object value = values.get(columnName);
		if (value == null)
			continue;

		Class<?> type = table.getColumn(columnName).getType();
		if (type == List.class) {
			type = table.getColumn(columnName).getListElementType();
			writeList(type, columnName, (List<?>) value, jgen);
		} else {
			jgen.writeFieldName(replaceColumnName(columnName));
			writeValue(type, value, jgen);
		}
	}
}
 

import org.cytoscape.model.CyRow; //导入依赖的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.CyRow; //导入依赖的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.CyRow; //导入依赖的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.CyRow; //导入依赖的package包/类
/**
 * Gets the index of the data series row corresponding to a given CyRow under this mapping
 * @param row
 * @return -1 if there is no row for this CyRow, or the index of the associated row.
 * @throws DataSeriesException if the CyRow contains an invalid ID.
 */
public int getDataSeriesRow(CyRow row)
{
	Integer rowID = row.get(columnName, DataSeriesMappingManager.MAPPING_COLUMN_CLASS);
	if(rowID == null)
	{
		return -1;
	}
	int tsRow = dataSeries.idToRow(rowID);
	if(tsRow < 0)
	{
		throw new DataSeriesException("Requesting non existent row id (" + tsRow + ") from Data Series " + dataSeries.getName());			
	}
	return tsRow;
}
 

import org.cytoscape.model.CyRow; //导入依赖的package包/类
void setEnrichmentLandscape(EnrichmentLandscape landscape) {
    if (session == null) {
        notifyListeners();
        return;
    }

    isEnabled = true;

    Long[] nodeMappings = session.getNodeMappings();
    if (nodeMappings == null) {
        notifyListeners();
        return;
    }

    CyNetworkView view = session.getNetworkView();
    CyNetwork network = view.getModel();
    CyTable nodeTable = network.getDefaultNodeTable();
    nodeTableId = nodeTable.getSUID();

    Arrays.stream(nodeMappings)
          .forEach(suid -> {
              CyRow row = nodeTable.getRow(suid);
              boolean selected = row.get(CyNetwork.SELECTED, Boolean.class);
              if (selected) {
                  nodeSuids.add(suid);
              }
          });

    notifyListeners();
}
 

import org.cytoscape.model.CyRow; //导入依赖的package包/类
@Override
public void handleEvent(RowsSetEvent event) {
    if (nodeTableId == null || !isEnabled) {
        return;
    }

    if (event.getSource()
             .getSUID() != nodeTableId) {
        return;
    }

    int initialSize = nodeSuids.size();
    Collection<RowSetRecord> records = event.getColumnRecords(CyNetwork.SELECTED);
    records.stream()
           .forEach(record -> {
               CyRow row = record.getRow();
               Long suid = row.get(CyNetwork.SUID, Long.class);
               if (Boolean.TRUE.equals(record.getValue())) {
                   nodeSuids.add(suid);
               } else {
                   nodeSuids.removeAll(suid);
               }
           });

    if (nodeSuids.size() != initialSize) {
        notifyListeners();
    }
}
 

import org.cytoscape.model.CyRow; //导入依赖的package包/类
private void selectSignificantNodes() {
    SignificancePredicate predicate = getSignificancePredicate();
    int[] rows = filteredTable.getTable()
                              .getSelectedRows();
    TableRowSorter<TableModel> sorter = filteredTable.getSorter();
    Long[] nodeMappings = session.getNodeMappings();

    CyNetworkView view = session.getNetworkView();
    CyNetwork network = view.getModel();
    CyTable nodeTable = network.getDefaultNodeTable();
    CyTable edgeTable = network.getDefaultEdgeTable();

    SafeUtil.clearSelection(nodeTable);
    SafeUtil.clearSelection(edgeTable);

    EnrichmentLandscape landscape = session.getEnrichmentLandscape();
    List<? extends Neighborhood> neighborhoods = landscape.getNeighborhoods();
    neighborhoods.stream()
                 .forEach(n -> {
                     boolean include = Arrays.stream(rows)
                                             .map(i -> sorter.convertRowIndexToModel(i))
                                             .filter(i -> predicate.test(n, i))
                                             .findAny()
                                             .isPresent();

                     Long suid = nodeMappings[n.getNodeIndex()];
                     CyRow row = nodeTable.getRow(suid);
                     row.set(CyNetwork.SELECTED, include);
                 });
}