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;
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public ExportDataSeriesTask(DataSeriesManager dataSeriesManager, DataSeriesStorageManager dataSeriesStorageManager) {
	dataSeries = new ListSingleSelection<>(dataSeriesManager.getAllDataSeries());
	this.dataSeriesStorageManager = dataSeriesStorageManager;
}
 

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

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
public RemoveColumnMappingTask(DataSeriesMappingManager mappingManager) {
	super();
	this.mappingManager = mappingManager;
	targetMapping = new ListSingleSelection<>(mappingManager.getAllMappingDescriptors());	
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
/**
 * Constructor
 * 
 * @param stream input biopax stream
 * @param inputName a file or pathway name (can be later updated using actual data)
 * @param cyServices api services
 * @param visualStyleUtil  biopax/sif visual style utilities
 */
public BioPaxReaderTask(InputStream stream, String inputName, 
		CyServices cyServices, VisualStyleUtil visualStyleUtil) 
{
	this.networks = new HashSet<CyNetwork>();
	this.stream = stream;
	this.inputName = inputName;
	this.cyServices = cyServices;
	this.visualStyleUtil = visualStyleUtil;
	
	// initialize the root networks Collection
	nameToRootNetworkMap = new HashMap<String, CyRootNetwork>();
	for (CyNetwork net : cyServices.networkManager.getNetworkSet()) {
		final CyRootNetwork rootNet = cyServices.rootNetworkManager.getRootNetwork(net);
		if (!nameToRootNetworkMap.containsValue(rootNet))
			nameToRootNetworkMap.put(rootNet.getRow(rootNet).get(CyRootNetwork.NAME, String.class), rootNet);
	}		
	List<String> rootNames = new ArrayList<String>();
	rootNames.add(CREATE_NEW_COLLECTION);
	rootNames.addAll(nameToRootNetworkMap.keySet());
	rootNetworkSelection = new ListSingleSelection<String>(rootNames);
	rootNetworkSelection.setSelectedValue(CREATE_NEW_COLLECTION);

	// initialize the list of data processing modes
	readerMode = new ListSingleSelection<>(ReaderMode.values());
	readerMode.setSelectedValue(ReaderMode.DEFAULT);
	
	// init the SIF rules/patterns list
	sifSelection = new ListMultipleSelection<SIFType>(SIFEnum.values());
	sifSelection.setSelectedValues(sifSelection.getPossibleValues());

	//TODO init SBGN options
	sbgnSelection = new ListSingleSelection<String>();
	
	// initialize renderer list
	final List<NetworkViewRenderer> renderers = new ArrayList<>();
	final Set<NetworkViewRenderer> rendererSet = cyServices.applicationManager.getNetworkViewRendererSet();
	// If there is only one registered renderer, we don't want to add it to the List Selection,
	// so the combo-box does not appear to the user, since there is nothing to select anyway.
	if (rendererSet.size() > 1) {
		renderers.addAll(rendererSet);
		Collections.sort(renderers, new Comparator<NetworkViewRenderer>() {
			@Override
			public int compare(NetworkViewRenderer r1, NetworkViewRenderer r2) {
				return r1.toString().compareToIgnoreCase(r2.toString());
			}
		});
	}
	rendererList = new ListSingleSelection<>(renderers);
}
 

import org.cytoscape.work.util.ListSingleSelection; //导入依赖的package包/类
/**
	 * Constructor
	 *  @param stream input biopax stream
	 * @param inputName a file or pathway name (can be later updated using actual data)
	 */
	public BioPaxReaderTask(InputStream stream, String inputName)
	{
		this.networks = new HashSet<CyNetwork>();
		this.stream = stream;
		this.inputName = inputName;

		// initialize the root networks Collection
		nameToRootNetworkMap = new HashMap<String, CyRootNetwork>();
		for (CyNetwork net : App.cyServices.networkManager.getNetworkSet()) {
			final CyRootNetwork rootNet = App.cyServices.rootNetworkManager.getRootNetwork(net);
			if (!nameToRootNetworkMap.containsValue(rootNet))
				nameToRootNetworkMap.put(rootNet.getRow(rootNet).get(CyRootNetwork.NAME, String.class), rootNet);
		}		
		List<String> rootNames = new ArrayList<String>();
		rootNames.add(CREATE_NEW_COLLECTION);
		rootNames.addAll(nameToRootNetworkMap.keySet());
		rootNetworkSelection = new ListSingleSelection<String>(rootNames);
		rootNetworkSelection.setSelectedValue(CREATE_NEW_COLLECTION);

		// initialize the list of data processing modes
		readerMode = new ListSingleSelection<>(ReaderMode.values());
		readerMode.setSelectedValue(ReaderMode.DEFAULT);
		
		// init the SIF rules/patterns list
		sifSelection = new ListMultipleSelection<SIFType>(SIFEnum.values());
		List<SIFType> values = sifSelection.getPossibleValues();
		//remove sif rules/types/patterns that we don't want to apply by default
		for(SIFType item : sifSelection.getPossibleValues()) {
			if(item == SIFEnum.NEIGHBOR_OF // excl. this ubiquitous but confusing type (not useful)
				|| item == SIFEnum.INTERACTS_WITH //excl. PPIs (mostly PSI-MI data)
//					|| item == SIFEnum.REACTS_WITH
			)
			{
				values.remove(item);
			}
		}
		sifSelection.setSelectedValues(values);

		// initialize renderer list
		final List<NetworkViewRenderer> renderers = new ArrayList<>();
		final Set<NetworkViewRenderer> rendererSet = App.cyServices.applicationManager.getNetworkViewRendererSet();
		// If there is only one registered renderer, we don't want to add it to the List Selection,
		// so the combo-box does not appear to the user, since there is nothing to select anyway.
		if (rendererSet.size() > 1) {
			renderers.addAll(rendererSet);
			Collections.sort(renderers, new Comparator<NetworkViewRenderer>() {
				@Override
				public int compare(NetworkViewRenderer r1, NetworkViewRenderer r2) {
					return r1.toString().compareToIgnoreCase(r2.toString());
				}
			});
		}
		rendererList = new ListSingleSelection<>(renderers);
	}