Java ListSingleSelection类代码示例

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public MapColumnTask(CyServiceRegistrar registrar) {
	this.applicationManager = registrar.getService(CyApplicationManager.class);
	this.mappingManager = registrar.getService(DataSeriesMappingManager.class);
	
	DataSeriesManager dataSeriesManager = registrar.getService(DataSeriesManager.class);
	CyNetworkManager networkManager = registrar.getService(CyNetworkManager.class);
	
	targetClass = new ListSingleSelection<>(new TargetClassInfo("Nodes", CyNode.class), new TargetClassInfo("Edges", CyEdge.class));
	dataSeries = new ListSingleSelection<>(dataSeriesManager.getAllDataSeries());
	existingColumnForMapping = new ListSingleSelection<>();
	mapRowNamesWithColumn = new ListSingleSelection<>();
	
	targetNetwork = new ListSingleSelection<>(networkManager.getNetworkSet().stream().toArray(CyNetwork[]::new));
	if(applicationManager.getCurrentNetwork() != null)
	{
		targetNetwork.setSelectedValue(applicationManager.getCurrentNetwork());
	}
	
	updateExistingColumnForMapping(CyNode.class);
	updateMapRowNamesWithColumn(CyNode.class);
	
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public AbstractImportTask(CyServiceRegistrar registrar) {
	super();
	this.registrar = registrar;
	this.dataSeriesManager = registrar.getService(DataSeriesManager.class);
	
	DataSeriesImportManager importManager = registrar.getService(DataSeriesImportManager.class);
	
	this.provider = new ListSingleSelection<>(importManager.getAllImportProviders().stream()
			.map(x -> new ProviderDisplay(x))
			.collect(Collectors.toList()));
	
	Optional<ProviderDisplay> timeSeriesDisplay = provider.getPossibleValues().stream()
			.filter(x -> 
				x.getProvider().getImportedClass() != null && TimeSeries.class.isAssignableFrom(x.getProvider().getImportedClass()))
			.findAny();
	
	if(timeSeriesDisplay.isPresent())
	{
		provider.setSelectedValue(timeSeriesDisplay.get());
	}
	
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public void setSoftFile(SoftFile file)
{
	softFile = file;		
	if(file.getTables().size() > 1)
	{
		List<StringAndIndex> choice = new ArrayList<>();
		for(int i = 0; i < file.getTables().size(); i++)
		{
			SoftTable softTable = file.getTables().get(i);
			choice.add(new StringAndIndex(i, softTable.getType().toString() + ": " + softTable.getCaption()));
		}
		tableSelection = new ListSingleSelection<>(choice);
	}
	else
	{
		tableSelection = null; //makes the GUI skip the prompt
	}
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的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.work.util.ListSingleSelection; //导入依赖的package包/类
@Tunable(description="Existing column", groups={"Column"}, dependsOn="createNewColumn=false", listenForChange ={"targetClass","targetNetwork"})
public ListSingleSelection<String> getExistingColumnForMapping()
{
	if(!updatingExistingColumnForMapping)
	{
		updatingExistingColumnForMapping = true;
		try {
			updateExistingColumnForMapping(targetClass.getSelectedValue().getTargetClass());
		} finally {
			updatingExistingColumnForMapping = false;
		}
	}
	return existingColumnForMapping;
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
@Tunable(description="Column to match row names", groups={"Mapping"}, dependsOn="mapByRowNames=true", listenForChange ="targetClass")
public ListSingleSelection<String> getMapRowNamesWithColumn()
{
	if(!updatingMapRowNamesWithColumn)
	{
		updatingMapRowNamesWithColumn = true;
		try 
		{
			updateMapRowNamesWithColumn(targetClass.getSelectedValue().getTargetClass());
		} finally {
			updatingMapRowNamesWithColumn = false;
		}
	}
	return mapRowNamesWithColumn;
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的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.work.util.ListSingleSelection; //导入依赖的package包/类
public SmoothDataSeriesTask(CyServiceRegistrar registrar) {
	this.dataSeriesManager = registrar.getService(DataSeriesManager.class);
	this.smoothingService = registrar.getService(SmoothingService.class);
	this.registrar = registrar;
	timeSeries = new ListSingleSelection<>(dataSeriesManager.getDataSeriesByType(TimeSeries.class));
	outputParameters = new SmoothingOutputParameters();
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public BaseExportReportsTask(SafeSession session) {

        CyNetworkView view = session.getNetworkView();
        CyNetwork network = view.getModel();
        nodeTable = network.getDefaultNodeTable();
        List<String> names = SafeUtil.getStringColumnNames(nodeTable)
                                     .collect(Collectors.toList());
        nodeNameColumn = new ListSingleSelection<>(names);

        nodeNameColumn.setSelectedValue(CyNetwork.NAME);

        this.session = session;
    }
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public static ListSingleSelection<String> listSingleSelectionFromEnum(Enum<?>[] values) {
	List<String> names = new ArrayList<>(values.length);
	for(Enum<?> value : values) {
		names.add(value.name());
	}
	return new ListSingleSelection<>(names);
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public ExpandNetworkTask(CyNetworkView cyNetworkView, View<CyNode> cyNodeView) 
{
	network = cyNetworkView.getModel();
	columnSelection = getTargetColumns();
	querySelection = new ListSingleSelection<String>("NEIGHBORHOOD","PATHSBETWEEN");
	querySelection.setSelectedValue("NEIGHBORHOOD");
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public SmoothInteractiveShowUITask(CyServiceRegistrar registrar) {
	this.registrar = registrar;
	timeSeries = new ListSingleSelection<>(registrar.getService(DataSeriesManager.class).getDataSeriesByType(TimeSeries.class));
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public ExponentiateDataSeriesTask(DataSeriesManager dataSeriesManager) {
	dataSeries = new ListSingleSelection<>(
			dataSeriesManager.getDataSeriesByType(DoubleDataSeries.class));
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public void setExistingColumnForMapping(ListSingleSelection<String> columnsForMapping)
{
	this.existingColumnForMapping = columnsForMapping;
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public void setMapRowNamesWithColumn(ListSingleSelection<String> mapRowNamesWithColumn)
{
	this.mapRowNamesWithColumn = mapRowNamesWithColumn;
}