Attachment #52498 for bug #157059

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 1042-1048 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupViewer.java (-1 / +1 lines)
1042	if(wc != null) {	1042	if(wc != null) {
1043	Set modes = wc.getModes();	1043	Set modes = wc.getModes();
1044	modes.add(getLaunchConfigurationDialog().getMode());	1044	modes.add(getLaunchConfigurationDialog().getMode());
1045	return wc.getType().supportsModeCombination(modes);	1045	return wc.getType().supportsModes(modes);
1046	}	1046	}
1047	} catch (CoreException e) {	1047	} catch (CoreException e) {
1048	}	1048	}





import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;


	
	private CheckboxTableViewer fTableViewer = null;
	private Table fTable  = null;
	private List fValidModes = null;
	
	/**
	 * Constructor

		super.setMessage(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_2);
		super.setTitle(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_3);
		setShellStyle(getShellStyle() | SWT.RESIZE);
		fValidModes = new ArrayList();
		Set modes = configuration.getType().getSupportedModes();
		Set modeset = null;
		for(Iterator iter = modes.iterator(); iter.hasNext();) {
			modeset = (Set) iter.next();
			if(modeset.contains(mode)) {
				fValidModes.add(modeset);
			}
		}
	}

		fTableViewer = new CheckboxTableViewer(fTable);
		fTableViewer.setLabelProvider(new OptionsLabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.setInput(fValidModes.toArray());
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fTableViewer.setAllChecked(false);

Lines 47-52 Link Here

(-)schema/launchDelegates.exsd (-1 / +29 lines)
47	</annotation>	47	</annotation>
48	<complexType>	48	<complexType>
49	<sequence minOccurs="0" maxOccurs="unbounded">	49	<sequence minOccurs="0" maxOccurs="unbounded">
		50	<element ref="modesCombination" minOccurs="1" maxOccurs="unbounded"/>
50	</sequence>	51	</sequence>
51	<attribute name="id" type="string" use="required">	52	<attribute name="id" type="string" use="required">
52	<annotation>	53	<annotation>
Lines 88-93 Link Here
88	<documentation>	89	<documentation>
89	A comma-separated list of the launch modes this lauch delegate supports.	90	A comma-separated list of the launch modes this lauch delegate supports.
90	</documentation>	91	</documentation>
		92	<appInfo>
		93	<meta.attribute deprecated="true"/>
		94	</appInfo>
91	</annotation>	95	</annotation>
92	</attribute>	96	</attribute>
93	<attribute name="type" type="string">	97	<attribute name="type" type="string">
Lines 128-133 Link Here
128	</complexType>	132	</complexType>
129	</element>	133	</element>
130		134
		135	<element name="modesCombination">
		136	<annotation>
		137	<documentation>
		138	This element represents a colleciton of mode combinations that this delegate can launch
		139
		140	since 3.3
		141
		142	EXPERIMENTAL
		143	</documentation>
		144	</annotation>
		145	<complexType>
		146	<attribute name="modes" type="string" use="required">
		147	<annotation>
		148	<documentation>
		149	the modes attribute represent a comma seperated listing of the combination of modes that the associated delegate can launch
		150
		151	since 3.3
		152
		153	EXPERIMENTAL
		154	</documentation>
		155	</annotation>
		156	</attribute>
		157	</complexType>
		158	</element>
		159
131	<annotation>	160	<annotation>
132	<appInfo>	161	<appInfo>
133	<meta.section type="since"/>	162	<meta.section type="since"/>
Lines 159-165 Link Here
159	</p>	188	</p>
160		189
161	In the example above, the specified launch delegate is contributed to launch Java applications in profile mode. The delegate supports mixed mode launching. The delegate supports profiling when launching in run or debug mode.	190	In the example above, the specified launch delegate is contributed to launch Java applications in profile mode. The delegate supports mixed mode launching. The delegate supports profiling when launching in run or debug mode.
162
163	</documentation>	191	</documentation>
164	</annotation>	192	</annotation>
165		193

Lines 13-19 Link Here

(-)schema/launchModes.exsd (-3 / +1 lines)
13	<element name="extension">	13	<element name="extension">
14	<complexType>	14	<complexType>
15	<sequence>	15	<sequence>
16	<element ref="launchMode" minOccurs="0" maxOccurs="unbounded"/>	16	<element ref="launchMode" minOccurs="1" maxOccurs="unbounded"/>
17	</sequence>	17	</sequence>
18	<attribute name="point" type="string" use="required">	18	<attribute name="point" type="string" use="required">
19	<annotation>	19	<annotation>
Lines 32-39 Link Here
32	</appInfo>	32	</appInfo>
33	</annotation>	33	</annotation>
34	<complexType>	34	<complexType>
35	<sequence>
36	</sequence>
37	<attribute name="mode" type="string" use="required">	35	<attribute name="mode" type="string" use="required">
38	<annotation>	36	<annotation>
39	<documentation>	37	<documentation>

Lines 147-152 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationType.java (-29 / +37 lines)
147	throw new CoreException(status);	147	throw new CoreException(status);
148	}	148	}
149		149
		150	/* (non-Javadoc)
		151	* @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegates(java.util.Set)
		152	*/
150	public ILaunchDelegateProxy[] getDelegates(Set modes) throws CoreException {	153	public ILaunchDelegateProxy[] getDelegates(Set modes) throws CoreException {
151	initializeDelegates();	154	initializeDelegates();
152	Object[] theModes = modes.toArray();	155	Object[] theModes = modes.toArray();
Lines 164-181 Link Here
164	return (ILaunchDelegateProxy[]) delegates.toArray(new ILaunchDelegateProxy[delegates.size()]);	167	return (ILaunchDelegateProxy[]) delegates.toArray(new ILaunchDelegateProxy[delegates.size()]);
165	}	168	}
166		169
		170	/**
		171	* Initializes the listing of launch delegates for this type
		172	*/
167	private synchronized void initializeDelegates() {	173	private synchronized void initializeDelegates() {
168	if (fDelegates == null) {	174	if (fDelegates == null) {
169	// initialize delegate	175	// initialize delegate
170	fDelegates = new Hashtable();	176	fDelegates = new Hashtable();
171	LaunchDelegate[] launchDelegates = getLaunchDelegateExtensions();	177	LaunchDelegate[] launchDelegates = getLaunchDelegateExtensions();
		178	LaunchDelegate delegate = null;
		179	List modelist = null;
172	for (int i = 0; i < launchDelegates.length; i++) {	180	for (int i = 0; i < launchDelegates.length; i++) {
173	LaunchDelegate delegate = launchDelegates[i];	181	delegate = launchDelegates[i];
174	List combintaions = delegate.getModeCombinations();	182	modelist = delegate.getModes();
175	Iterator iterator = combintaions.iterator();	183	for(int j = 0; j < modelist.size(); j++) {
176	while (iterator.hasNext()) {	184	//cache the delegate based on its set of modes and delegate
177	Set combination = (Set) iterator.next();	185	registerDelegate(delegate, (Set) modelist.get(j));
178	registerDelegate(delegate, combination);
179	}	186	}
180	}	187	}
181	}	188	}
Lines 190-195 Link Here
190	return ((LaunchManager) DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(getIdentifier());	197	return ((LaunchManager) DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(getIdentifier());
191	}	198	}
192		199
		200	/**
		201	* Caches a delegate keyed using the set of modes that it supports
		202	* @param delegate the delegate to cache
		203	* @param modes the set of modes that the specified delegate supports
		204	*/
193	private void registerDelegate(LaunchDelegate delegate, Set modes) {	205	private void registerDelegate(LaunchDelegate delegate, Set modes) {
194	List delegatesForModes = (List) fDelegates.get(modes);	206	List delegatesForModes = (List) fDelegates.get(modes);
195	if (delegatesForModes == null) {	207	if (delegatesForModes == null) {
Lines 287-301 Link Here
287	*/	299	*/
288	public Set getSupportedModes() {	300	public Set getSupportedModes() {
289	if(fModes == null) {	301	if(fModes == null) {
		302	initializeDelegates();
290	fModes = new HashSet();	303	fModes = new HashSet();
291	LaunchDelegate[] delegates = getLaunchDelegateExtensions();	304	fModes = fDelegates.keySet();
292	for(int i= 0; i < delegates.length; i++) {
293	fModes.addAll(delegates[i].getModes());
294	}
295	}	305	}
296	return fModes;	306	return fModes;
297	}	307	}
298		308
299	/**	309	/**
300	* determines if the specified candidate is suitable for migration by loading it delegate.	310	* determines if the specified candidate is suitable for migration by loading it delegate.
301	* @param candidate the candidate to inspect for migration suitability	311	* @param candidate the candidate to inspect for migration suitability
Lines 368-374 Link Here
368	* @see org.eclipse.debug.core.ILaunchConfigurationType#supportsMode(java.lang.String)	378	* @see org.eclipse.debug.core.ILaunchConfigurationType#supportsMode(java.lang.String)
369	*/	379	*/
370	public boolean supportsMode(String mode) {	380	public boolean supportsMode(String mode) {
371	return getSupportedModes().contains(mode);	381	if(fModes == null) {
		382	getSupportedModes();
		383	}
		384	Set modes = null;
		385	for(Iterator iter = fModes.iterator(); iter.hasNext();) {
		386	modes = (Set) iter.next();
		387	if(modes.size() == 1 & modes.contains(mode)) {
		388	return true;
		389	}
		390	}
		391	return false;
372	}	392	}
373		393
374	/* (non-Javadoc)	394	/* (non-Javadoc)
Lines 386-410 Link Here
386	}	406	}
387		407
388	/* (non-Javadoc)	408	/* (non-Javadoc)
389	* @see org.eclipse.debug.core.ILaunchConfigurationType#getSupportedModeCombinations()
390	*/
391	public Set[] getSupportedModeCombinations() {
392	initializeDelegates();
393	Set combinations = fDelegates.keySet();
394	Set[] sets = (Set[])combinations.toArray(new Set[combinations.size()]);
395	Set[] copy = new Set[sets.length];
396	for (int i = 0; i < copy.length; i++) {
397	copy[i] = new HashSet(sets[i]);
398	}
399	return copy;
400	}
401
402	/* (non-Javadoc)
403	* @see org.eclipse.debug.core.ILaunchConfigurationType#supportsModeCombination(java.util.Set)	409	* @see org.eclipse.debug.core.ILaunchConfigurationType#supportsModeCombination(java.util.Set)
404	*/	410	*/
405	public boolean supportsModeCombination(Set modes) {	411	public boolean supportsModes(Set modes) {
406	initializeDelegates();	412	if(fModes == null) {
407	return fDelegates.containsKey(modes);	413	getSupportedModes();
		414	}
		415	return fModes.contains(modes);
408	}	416	}
409		417
410	}	418	}




package org.eclipse.debug.internal.core;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;


	 */
	private ILaunchConfigurationDelegate fDelegate = null;
	
	//a listing of sets of 
	private List fLaunchModes = null;
	private HashSet fModes = null;
	private HashSet fOptions = null;
	private String fType = null;
	
	/**

		fElement = element;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegateProxy#getDelegate()
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
		if(fDelegate == null) {
			Object obj = fElement.createExecutableExtension(IConfigurationElementConstants.DELEGATE);

		return fDelegate;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegateProxy#getId()
	 */
	public String getId() {
		return fElement.getAttribute(IConfigurationElementConstants.ID);
	}

		}
		return fType;
	}

	public Set getOptions() {
		if(fOptions == null) {
			fOptions = new HashSet();
			String option = fElement.getAttribute(IConfigurationElementConstants.OPTIONS);
			if(option != null) {
				String[] options = option.split(","); //$NON-NLS-1$
				for(int i = 0; i < options.length; i++) {
					fOptions.add(options[i].trim());
				}
			}
		}
		return fOptions;
	}
	
	/**
	 * Parese a list of modes and creates a new set of them
	 * @param element the configuraiton element to read from
	 * @return a set of launch modes created form a comma seperated list
	 */
	private Set getModes(IConfigurationElement element) {
		if (fModes == null) {
			fModes = new HashSet();
			String modes = element.getAttribute(IConfigurationElementConstants.MODES); 
			if (modes != null) {
				String[] strings = modes.split(","); //$NON-NLS-1$
				for (int i = 0; i < strings.length; i++) {

		return fModes;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegateProxy#getModes()
	 */
	public List getModes() {
		if(fLaunchModes == null) {
			fLaunchModes = new ArrayList();
			IConfigurationElement[] children = fElement.getChildren(IConfigurationElementConstants.MODES_COMBINATION);
			for (int i = 0; i < children.length; i++) {
				fLaunchModes.add(getModes(children[i]));
			}
			if(fLaunchModes.size() == 0) {
				//try to get the modes from the old definition and make each one
				//a seperate set of one element
				String modes = fElement.getAttribute(IConfigurationElementConstants.MODES); 
				if (modes != null) {
					String[] strings = modes.split(","); //$NON-NLS-1$
					HashSet modeset = null;
					for (int i = 0; i < strings.length; i++) {
						modeset = new HashSet();
						modeset.add(strings[i].trim());
						fLaunchModes.add(modeset);
					}
				}
			}
		}
		return fLaunchModes;
	}
	
	/**
	 * Returns the human readable name for this launch delegate
	 * @return the human readable name for this launch delegate, or <code>null</code> if none

	public String getSourcePathComputerId() {
		return fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);
	}

	/**
	 * Returns all combinations of supported options.
	 * 
	 * @return combinations of supported options
	 */
	private Collection getOptionSets() {
		Set optionSets = new HashSet(); 
		optionSets.add(new HashSet()); // seed with the empty option set
		Object[] options = getOptions().toArray();
		boolean grew = false;
		do {
			grew = false;
			Set[] sets = (Set[]) optionSets.toArray(new Set[optionSets.size()]);
			for (int i = 0; i < sets.length; i++) {
				Set optionSet = sets[i];
				for (int j = 0; j < options.length; j++) {
					Object option = options[j];
					Set newOptionSet = new HashSet(optionSet);
					if (newOptionSet.add(option)) {
						if (optionSets.add(newOptionSet)) {
							grew = true;
						}
					}
				}				
			}                                   
		} while (grew);
		return optionSets;
	}
	
	/**
	 * Returns all supported launch mode combinations as sets of modes.
	 *  
	 * @return all supported launch mode combinations
	 */
	List getModeCombinations() {
		Collection optionSets = getOptionSets();
		Object[] modes = getModes().toArray();
		List combinations = new ArrayList(optionSets.size() * modes.length);
		Iterator iterator = optionSets.iterator();
		while (iterator.hasNext()) {
			Set optionSet = (Set) iterator.next();
			for (int i = 0; i < modes.length; i++) {
				Object mode = modes[i];
				Set set = new HashSet(optionSet);
				set.add(mode);
				combinations.add(set);
			}			
		}
		return combinations;
	}
}

Lines 82-87 Link Here

(-)core/org/eclipse/debug/internal/core/IConfigurationElementConstants.java (+5 lines)
82	public static final String MODES = "modes"; //$NON-NLS-1$	82	public static final String MODES = "modes"; //$NON-NLS-1$
83		83
84	/**	84	/**
		85	* the modesCombination node name for a configuraiton element
		86	*/
		87	public static final String MODES_COMBINATION = "modesCombination"; //$NON-NLS-1$
		88
		89	/**
85	* the mode node name for a configuration element	90	* the mode node name for a configuration element
86	*/	91	*/
87	public static final String MODE = "mode"; //$NON-NLS-1$	92	public static final String MODE = "mode"; //$NON-NLS-1$




	public ILaunchDelegateProxy[] getDelegates(Set modes) throws CoreException;
	
	/**
	 * Returns a collection of all supported launch mode combinations for 
	 * this launch configuration type.
	 * 
	 * @return all supported launch mode combinations
	 * @since 3.3
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public Set[] getSupportedModeCombinations();
	
	/**
	 * Returns whether this launch configuration supports the specified launch
	 * mode combination.
	 * 

	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public boolean supportsModes(Set modes);
	
	/**
	 * Returns the unique identifier for this type of launch configuration

	 * Returns all of the registered supported modes for this launch configuration type.
	 * This method does not return null.
	 * 
	 * <p>
	 * The Set returned is either empty, or a set of sets where each entry is an 
	 * inclusive set of individually declared mode combination entries.
	 * </p>
	 * 
	 * @return the set of all supported modes
	 * @since 3.2
	 */




 *******************************************************************************/
package org.eclipse.debug.core;

import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;

	public ILaunchConfigurationDelegate getDelegate() throws CoreException;
	
	/**
	 * Returns the complete set of launch modes as a list of sets.
	 * If no modes are available an empty list is returned, never <code>null</code>
	 * @return the complete set of launch modes for this delegate as a list
	 * of sets
	public Set getModes();
	
	/**
	 * Returns the launch modes this delegate supports in combination with
	 * its modes specified by <code>getModes()</code>.
	 * 
	 * @return launch options as a set of launch mode identifiers
	 */
	public List getModes();
	
}

Return to bug 157059

Lines 12-17 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/SelectLaunchModesDialog.java (-8 / +10 lines)
12		12
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.Arrays;	14	import java.util.Arrays;
		15	import java.util.Iterator;
15	import java.util.List;	16	import java.util.List;
16	import java.util.Set;	17	import java.util.Set;
17		18
Lines 72-78 Link Here
72		73
73	private CheckboxTableViewer fTableViewer = null;	74	private CheckboxTableViewer fTableViewer = null;
74	private Table fTable = null;	75	private Table fTable = null;
75	private List fValidCombinations;	76	private List fValidModes = null;
76		77
77	/**	78	/**
78	* Constructor	79	* Constructor
Lines 85-96 Link Here
85	super.setMessage(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_2);	86	super.setMessage(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_2);
86	super.setTitle(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_3);	87	super.setTitle(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_3);
87	setShellStyle(getShellStyle() \| SWT.RESIZE);	88	setShellStyle(getShellStyle() \| SWT.RESIZE);
88	Set[] combinations = configuration.getType().getSupportedModeCombinations();	89	fValidModes = new ArrayList();
89	fValidCombinations = new ArrayList();	90	Set modes = configuration.getType().getSupportedModes();
90	for (int i = 0; i < combinations.length; i++) {	91	Set modeset = null;
91	Set set = combinations[i];	92	for(Iterator iter = modes.iterator(); iter.hasNext();) {
92	if (set.contains(mode)) {	93	modeset = (Set) iter.next();
93	fValidCombinations.add(set);	94	if(modeset.contains(mode)) {
		95	fValidModes.add(modeset);
94	}	96	}
95	}	97	}
96	}	98	}
Lines 107-113 Link Here
107	fTableViewer = new CheckboxTableViewer(fTable);	109	fTableViewer = new CheckboxTableViewer(fTable);
108	fTableViewer.setLabelProvider(new OptionsLabelProvider());	110	fTableViewer.setLabelProvider(new OptionsLabelProvider());
109	fTableViewer.setContentProvider(new ArrayContentProvider());	111	fTableViewer.setContentProvider(new ArrayContentProvider());
110	fTableViewer.setInput(fValidCombinations.toArray());	112	fTableViewer.setInput(fValidModes.toArray());
111	fTableViewer.addCheckStateListener(new ICheckStateListener() {	113	fTableViewer.addCheckStateListener(new ICheckStateListener() {
112	public void checkStateChanged(CheckStateChangedEvent event) {	114	public void checkStateChanged(CheckStateChangedEvent event) {
113	fTableViewer.setAllChecked(false);	115	fTableViewer.setAllChecked(false);

Lines 11-19 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchDelegate.java (-71 / +43 lines)
11	package org.eclipse.debug.internal.core;	11	package org.eclipse.debug.internal.core;
12		12
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.Collection;
15	import java.util.HashSet;	14	import java.util.HashSet;
16	import java.util.Iterator;
17	import java.util.List;	15	import java.util.List;
18	import java.util.Set;	16	import java.util.Set;
19		17
Lines 59-67 Link Here
59	*/	57	*/
60	private ILaunchConfigurationDelegate fDelegate = null;	58	private ILaunchConfigurationDelegate fDelegate = null;
61		59
62	//lists of cached entries	60	//a listing of sets of
		61	private List fLaunchModes = null;
63	private HashSet fModes = null;	62	private HashSet fModes = null;
64	private HashSet fOptions = null;
65	private String fType = null;	63	private String fType = null;
66		64
67	/**	65	/**
Lines 72-77 Link Here
72	fElement = element;	70	fElement = element;
73	}	71	}
74		72
		73	/* (non-Javadoc)
		74	* @see org.eclipse.debug.core.ILaunchDelegateProxy#getDelegate()
		75	*/
75	public ILaunchConfigurationDelegate getDelegate() throws CoreException {	76	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
76	if(fDelegate == null) {	77	if(fDelegate == null) {
77	Object obj = fElement.createExecutableExtension(IConfigurationElementConstants.DELEGATE);	78	Object obj = fElement.createExecutableExtension(IConfigurationElementConstants.DELEGATE);
Lines 84-89 Link Here
84	return fDelegate;	85	return fDelegate;
85	}	86	}
86		87
		88	/* (non-Javadoc)
		89	* @see org.eclipse.debug.core.ILaunchDelegateProxy#getId()
		90	*/
87	public String getId() {	91	public String getId() {
88	return fElement.getAttribute(IConfigurationElementConstants.ID);	92	return fElement.getAttribute(IConfigurationElementConstants.ID);
89	}	93	}
Lines 103-127 Link Here
103	}	107	}
104	return fType;	108	return fType;
105	}	109	}
106
107	public Set getOptions() {
108	if(fOptions == null) {
109	fOptions = new HashSet();
110	String option = fElement.getAttribute(IConfigurationElementConstants.OPTIONS);
111	if(option != null) {
112	String[] options = option.split(","); //$NON-NLS-1$
113	for(int i = 0; i < options.length; i++) {
114	fOptions.add(options[i].trim());
115	}
116	}
117	}
118	return fOptions;
119	}
120		110
121	public Set getModes() {	111	/**
		112	* Parese a list of modes and creates a new set of them
		113	* @param element the configuraiton element to read from
		114	* @return a set of launch modes created form a comma seperated list
		115	*/
		116	private Set getModes(IConfigurationElement element) {
122	if (fModes == null) {	117	if (fModes == null) {
123	fModes = new HashSet();	118	fModes = new HashSet();
124	String modes = fElement.getAttribute(IConfigurationElementConstants.MODES);	119	String modes = element.getAttribute(IConfigurationElementConstants.MODES);
125	if (modes != null) {	120	if (modes != null) {
126	String[] strings = modes.split(","); //$NON-NLS-1$	121	String[] strings = modes.split(","); //$NON-NLS-1$
127	for (int i = 0; i < strings.length; i++) {	122	for (int i = 0; i < strings.length; i++) {
Lines 132-137 Link Here
132	return fModes;	127	return fModes;
133	}	128	}
134		129
		130	/* (non-Javadoc)
		131	* @see org.eclipse.debug.core.ILaunchDelegateProxy#getModes()
		132	*/
		133	public List getModes() {
		134	if(fLaunchModes == null) {
		135	fLaunchModes = new ArrayList();
		136	IConfigurationElement[] children = fElement.getChildren(IConfigurationElementConstants.MODES_COMBINATION);
		137	for (int i = 0; i < children.length; i++) {
		138	fLaunchModes.add(getModes(children[i]));
		139	}
		140	if(fLaunchModes.size() == 0) {
		141	//try to get the modes from the old definition and make each one
		142	//a seperate set of one element
		143	String modes = fElement.getAttribute(IConfigurationElementConstants.MODES);
		144	if (modes != null) {
		145	String[] strings = modes.split(","); //$NON-NLS-1$
		146	HashSet modeset = null;
		147	for (int i = 0; i < strings.length; i++) {
		148	modeset = new HashSet();
		149	modeset.add(strings[i].trim());
		150	fLaunchModes.add(modeset);
		151	}
		152	}
		153	}
		154	}
		155	return fLaunchModes;
		156	}
		157
135	/**	158	/**
136	* Returns the human readable name for this launch delegate	159	* Returns the human readable name for this launch delegate
137	* @return the human readable name for this launch delegate, or <code>null</code> if none	160	* @return the human readable name for this launch delegate, or <code>null</code> if none
Lines 164-218 Link Here
164	public String getSourcePathComputerId() {	187	public String getSourcePathComputerId() {
165	return fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);	188	return fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);
166	}	189	}
167
168	/**
169	* Returns all combinations of supported options.
170	*
171	* @return combinations of supported options
172	*/
173	private Collection getOptionSets() {
174	Set optionSets = new HashSet();
175	optionSets.add(new HashSet()); // seed with the empty option set
176	Object[] options = getOptions().toArray();
177	boolean grew = false;
178	do {
179	grew = false;
180	Set[] sets = (Set[]) optionSets.toArray(new Set[optionSets.size()]);
181	for (int i = 0; i < sets.length; i++) {
182	Set optionSet = sets[i];
183	for (int j = 0; j < options.length; j++) {
184	Object option = options[j];
185	Set newOptionSet = new HashSet(optionSet);
186	if (newOptionSet.add(option)) {
187	if (optionSets.add(newOptionSet)) {
188	grew = true;
189	}
190	}
191	}
192	}
193	} while (grew);
194	return optionSets;
195	}
196
197	/**
198	* Returns all supported launch mode combinations as sets of modes.
199	*
200	* @return all supported launch mode combinations
201	*/
202	List getModeCombinations() {
203	Collection optionSets = getOptionSets();
204	Object[] modes = getModes().toArray();
205	List combinations = new ArrayList(optionSets.size() * modes.length);
206	Iterator iterator = optionSets.iterator();
207	while (iterator.hasNext()) {
208	Set optionSet = (Set) iterator.next();
209	for (int i = 0; i < modes.length; i++) {
210	Object mode = modes[i];
211	Set set = new HashSet(optionSet);
212	set.add(mode);
213	combinations.add(set);
214	}
215	}
216	return combinations;
217	}
218	}	190	}

Lines 151-171 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfigurationType.java (-16 / +6 lines)
151	public ILaunchDelegateProxy[] getDelegates(Set modes) throws CoreException;	151	public ILaunchDelegateProxy[] getDelegates(Set modes) throws CoreException;
152		152
153	/**	153	/**
154	* Returns a collection of all supported launch mode combinations for
155	* this launch configuration type.
156	*
157	* @return all supported launch mode combinations
158	* @since 3.3
159	* <p>
160	* <strong>EXPERIMENTAL</strong>. This method has been added as
161	* part of a work in progress. There is no guarantee that this API will
162	* remain unchanged during the 3.3 release cycle. Please do not use this API
163	* without consulting with the Platform/Debug team.
164	* </p>
165	*/
166	public Set[] getSupportedModeCombinations();
167
168	/**
169	* Returns whether this launch configuration supports the specified launch	154	* Returns whether this launch configuration supports the specified launch
170	* mode combination.	155	* mode combination.
171	*	156	*
Lines 179-185 Link Here
179	* without consulting with the Platform/Debug team.	164	* without consulting with the Platform/Debug team.
180	* </p>	165	* </p>
181	*/	166	*/
182	public boolean supportsModeCombination(Set modes);	167	public boolean supportsModes(Set modes);
183		168
184	/**	169	/**
185	* Returns the unique identifier for this type of launch configuration	170	* Returns the unique identifier for this type of launch configuration
Lines 237-242 Link Here
237	* Returns all of the registered supported modes for this launch configuration type.	222	* Returns all of the registered supported modes for this launch configuration type.
238	* This method does not return null.	223	* This method does not return null.
239	*	224	*
		225	* <p>
		226	* The Set returned is either empty, or a set of sets where each entry is an
		227	* inclusive set of individually declared mode combination entries.
		228	* </p>
		229	*
240	* @return the set of all supported modes	230	* @return the set of all supported modes
241	* @since 3.2	231	* @since 3.2
242	*/	232	*/

Lines 10-16 Link Here

(-)core/org/eclipse/debug/core/ILaunchDelegateProxy.java (-13 / +6 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.debug.core;	11	package org.eclipse.debug.core;
12		12
13	import java.util.Set;	13	import java.util.List;
14		14
15	import org.eclipse.core.runtime.CoreException;	15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;	16	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
Lines 62-79 Link Here
62	public ILaunchConfigurationDelegate getDelegate() throws CoreException;	62	public ILaunchConfigurationDelegate getDelegate() throws CoreException;
63		63
64	/**	64	/**
65	* Returns the launch modes this delegate supports.	65	* Returns the complete set of launch modes as a list of sets.
66	*	66	* If no modes are available an empty list is returned, never <code>null</code>
67	* @return launch modes as a set of launch mode identifiers	67	* @return the complete set of launch modes for this delegate as a list
68	*/	68	* of sets
69	public Set getModes();
70
71	/**
72	* Returns the launch modes this delegate supports in combination with
73	* its modes specified by <code>getModes()</code>.
74	*
75	* @return launch options as a set of launch mode identifiers
76	*/	69	*/
77	public Set getOptions();	70	public List getModes();
78		71
79	}	72	}