/**

	 * Returns the template this launch configuration was created from

	 * or <code>null</code> if none.

	 * 

	 * @return the template this launch configuration was created from

	 *  or <code>null</code> if none

	 * @throws CoreException if the template could not be retrieved

	 *  or no longer exists

	 * @since 3.6

	 */

	public ILaunchConfiguration getTemplate() throws CoreException;

	/**

	 * Returns whether this configuration is a template.

	 * 

	 * @return whether this configuration is a template

	 * @throws CoreException if unable to determine if this configuration is a template

	 * @since 3.6

	 */

	public boolean isTemplate() throws CoreException;

	/**

	 * Returns all configurations made from this template, possibly an

	 * empty collection.

	 * 

	 * @return all configurations made from this template

	 * @throws CoreException

	 * @since 3.6

	 */

	public ILaunchConfiguration[] getTemplateChildren() throws CoreException;

import org.eclipse.core.runtime.preferences.IScopeContext;

	/**

	 * Sets the template for this launch configuration type in the specified scope,

	 * or removes the template for the scope when the specified configuration is

	 * <code>null</code>.

	 * 

	 * @param configuration template for the specified scope, or <code>null</code> if none

	 * @param scope scope

	 * @throws CoreException if unable to to set/remove the template for the given scope 

	 * @since 3.6

	 */

	public void setTemplate(ILaunchConfiguration configuration, IScopeContext scope) throws CoreException;

	/**

	 * Returns the template for this launch configuration type in the specified scope

	 * or <code>null</code> if no template has been set for the scope.

	 * 

	 * @param scope scope

	 * @return template for the scope or <code>null</code>

	 * @throws CoreException if unable to retrieve the template for the scope

	 * @since 3.6

	 */

	public ILaunchConfiguration getTemplate(IScopeContext scope) throws CoreException;

	/**

	 * Returns all launch configuration templates of the this type, possibly

	 * an empty collection.

	 * 

	 * @return all launch configuration templates of the this type

	 * @throws CoreException if unable to retrieve the templates 

	 * @since 3.6

	 */

	public ILaunchConfiguration[] getTemplates() throws CoreException;	

	/**

	 * Returns a new launch configuration working copy of this type,

	 * that resides in the specified container, with the given name, initialized

	 * with values in the first template found in the given canonical scope order.

	 * When <code>container</code> is </code>null</code>, the configuration

	 * will reside locally in the metadata area.

	 * Note: a launch configuration is not actually created until the working copy is saved.

	 * 

	 * @param container the container in which the new configuration will

	 *  reside, or <code>null</code> if the configuration should reside

	 *  locally with the metadata.

	 * @param name name for the launch configuration

	 * @param scopes optional context objects to determine which scopes are search

	 *  for a launch configuration template, or <code>null</code> if template scopes

	 *  should not be considered

	 * @return a new launch configuration working copy instance of this type

	 * @exception CoreException if an instance of this type

	 *  of launch configuration could not be created for any

	 *  reason

	 * @since 3.6

	 */

	public ILaunchConfigurationWorkingCopy newInstance(IContainer container, String name, IScopeContext[] scopes) throws CoreException;	

	/**

	 * Copies all attributes from the given template to this working.

	 * Overwrites any existing attributes with the same key.

	 * 

	 * @param template configuration template

	 * @exception CoreException if unable to retrieve attributes from the template

	 * @since 3.6

	 */

	public void copyAttributes(ILaunchConfiguration template) throws CoreException;

	/**

	 * Sets whether this configuration is to be considered as a template.

	 * 

	 * @param isTemplate whether this configuration is to be considered as a template

	 * @since 3.6

	 */

	public void setTemplate(boolean isTemplate);

	/**

	 * Sets the template that this configuration is associated with, possibly <code>null</code>.

	 * <p>

	 * When the specified template is <code>null</code>, this working copy is no longer

	 * associated with any template.

	 * </p>

	 * @param template template or <code>null</code>

	 * @exception CoreException if unable to generate a memento for the given configuration

	 * @since 3.6

	 */

	public void setTemplate(ILaunchConfiguration template) throws CoreException;

	public static String LaunchConfigurationType_0;

	public static String LaunchConfigurationType_1;

LaunchConfigurationType_0=Error retrieving template

LaunchConfigurationType_1=Error setting template

	 * Launch configuration attribute storing a boolean indicating whether this 

	 * configuration is a template. Default value is <code>false</code>.

	 * 

	 * @since 3.6

	 */

	public static final String ATTR_IS_TEMPLATE = DebugPlugin.getUniqueIdentifier() + ".ATTR_IS_TEMPLATE"; //$NON-NLS-1$

	/**

	 * Launch configuration attribute storing a memento identifying the template

	 * this configuration was made from, possibly <code>null</code>.

	 * 

	 *  @since 3.6

	 */

	public static final String ATTR_TEMPLATE = DebugPlugin.getUniqueIdentifier() + ".ATTR_TEMPLATE"; //$NON-NLS-1$

	/**

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfiguration#getTemplate()

	 */

	public ILaunchConfiguration getTemplate() throws CoreException {

		String memento = getAttribute(ATTR_TEMPLATE, (String)null);

		if (memento != null) {

			return new LaunchConfiguration(memento);

		}

		return null;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfiguration#getTemplateChildren()

	 */

	public ILaunchConfiguration[] getTemplateChildren() throws CoreException {

		ILaunchConfiguration[] configurations = getLaunchManager().getLaunchConfigurations(getType());

		List proteges = new ArrayList();

		for (int i = 0; i < configurations.length; i++) {

			ILaunchConfiguration config = configurations[i];

			if (this.equals(config.getTemplate())) {

				proteges.add(config);

			}

		}

		return (ILaunchConfiguration[]) proteges.toArray(new ILaunchConfiguration[proteges.size()]);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfiguration#isTemplate()

	 */

	public boolean isTemplate() throws CoreException {

		return getAttribute(ATTR_IS_TEMPLATE, false);

	}

import java.util.ArrayList;

import org.eclipse.core.runtime.preferences.IEclipsePreferences;

import org.eclipse.core.runtime.preferences.IScopeContext;

import org.osgi.service.prefs.BackingStoreException;

import org.osgi.service.prefs.Preferences;

	 * A preference node that maps launch configuration type identifiers to

	 * default templates in that scope.

	 * 

	 * @since 3.6

	 */

	private static final String TEMPLATES_NODE = "TEMPLATES_NODE"; //$NON-NLS-1$

	/**

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getTemplate(org.eclipse.core.runtime.preferences.IScopeContext)

	 */

	public ILaunchConfiguration getTemplate(IScopeContext scope) throws CoreException {

		IEclipsePreferences node = scope.getNode(DebugPlugin.getUniqueIdentifier());

		try {

			if (node.nodeExists(TEMPLATES_NODE)) {

				Preferences templates = node.node(TEMPLATES_NODE);

				String memento = templates.get(getIdentifier(), null);

				if (memento != null) {

					return DebugPlugin.getDefault().getLaunchManager().getLaunchConfiguration(memento);

				}

			}

		} catch (BackingStoreException e) {

			throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugCoreMessages.LaunchConfigurationType_0, e));

		}

		return null;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getTemplates()

	 */

	public ILaunchConfiguration[] getTemplates() throws CoreException {

		ILaunchConfiguration[] configurations = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations(this);

		List templates = new ArrayList();

		for (int i = 0; i < configurations.length; i++) {

			ILaunchConfiguration config = configurations[i];

			if (config.isTemplate()) {

				templates.add(config);

			}

		}

		return (ILaunchConfiguration[]) templates.toArray(new ILaunchConfiguration[templates.size()]);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#newInstance(org.eclipse.core.resources.IContainer, java.lang.String, org.eclipse.core.runtime.preferences.IScopeContext[])

	 */

	public ILaunchConfigurationWorkingCopy newInstance(IContainer container, String name, IScopeContext[] scopes) throws CoreException {

		ILaunchConfiguration template = findTemplate(scopes);

		ILaunchConfigurationWorkingCopy wc = new LaunchConfigurationWorkingCopy(container, name, this);

		if (template != null) {

			wc.copyAttributes(template);

			wc.setTemplate(template);

		}

		return wc;

	}

	/**

	 * Returns the first template found in the given scopes or <code>null</code> if none.

	 * 

	 * @param contexts scopes to search in or <code>null</code>

	 * @return template or <code>null</code>

	 * @throws CoreException if unable to retrieve template

	 */

	private ILaunchConfiguration findTemplate(IScopeContext[] contexts) throws CoreException {

		if (contexts != null) {

			for (int i = 0; i < contexts.length; i++) {

				ILaunchConfiguration template = getTemplate(contexts[i]);

				if (template != null) {

					return template;

				}

			}

		}

		return null;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#setTemplate(org.eclipse.debug.core.ILaunchConfiguration, org.eclipse.core.runtime.preferences.IScopeContext)

	 */

	public void setTemplate(ILaunchConfiguration configuration, IScopeContext scope) throws CoreException {

		IEclipsePreferences node = scope.getNode(DebugPlugin.getUniqueIdentifier());

		Preferences templates = node.node(TEMPLATES_NODE);

		if (configuration == null) {

			templates.remove(getIdentifier());

			try {

				if (templates.keys().length == 0) {

					templates.removeNode();

				}

			} catch (BackingStoreException e) {

				throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugCoreMessages.LaunchConfigurationType_1, e));

			}

		} else {

			templates.put(getIdentifier(), configuration.getMemento());

		}

		try {

			node.flush();

		} catch (BackingStoreException e) {

			throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugCoreMessages.LaunchConfigurationType_1, e));

		}

	}

import java.util.Iterator;

import java.util.Map.Entry;

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#copyAttributes(org.eclipse.debug.core.ILaunchConfiguration)

	 */

	public void copyAttributes(ILaunchConfiguration template) throws CoreException {

		Map map = template.getAttributes();

		Iterator iterator = map.entrySet().iterator();

		LaunchConfigurationInfo info = getInfo();

		while (iterator.hasNext()) {

			Entry entry = (Entry) iterator.next();

			String attr = (String) entry.getKey();

			info.setAttribute(attr, entry.getValue());

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setTemplate(boolean)

	 */

	public void setTemplate(boolean isTemplate) {

		if (!isTemplate) {

			removeAttribute(ATTR_IS_TEMPLATE);

		} else {

			setAttribute(ATTR_IS_TEMPLATE, isTemplate);

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setTemplate(org.eclipse.debug.core.ILaunchConfiguration)

	 */

	public void setTemplate(ILaunchConfiguration template) throws CoreException {

		if (template == null) {

			removeAttribute(ATTR_TEMPLATE);

		} else {

			setAttribute(ATTR_TEMPLATE, template.getMemento());

		}

	}

import org.eclipse.core.resources.ProjectScope;

import org.eclipse.core.runtime.preferences.IScopeContext;

import org.eclipse.core.runtime.preferences.InstanceScope;

	/** 

	 * Creates and returns a new launch configuration with the given name, local

	 * or shared, with no attributes

	 */

	protected ILaunchConfigurationWorkingCopy newEmptyConfiguration(IContainer container, String name) throws CoreException {

		 ILaunchConfigurationType type = getLaunchManager().getLaunchConfigurationType(ID_TEST_LAUNCH_TYPE);

		 ILaunchConfigurationWorkingCopy wc = type.newInstance(container, name);

		 assertEquals("Should have no attributes", 0, wc.getAttributes().size());

		 return wc;

	}	

	/**

	 * Test copying attributes from one configuration to another.

	 * 

	 * @throws CoreException

	 */

	public void testCopyAttributes() throws CoreException {

		ILaunchConfigurationWorkingCopy source = newConfiguration(null, "test-copy-attributes-source");

		ILaunchConfigurationWorkingCopy dest = newEmptyConfiguration(null, "test-copy-attributes-dest");

		dest.copyAttributes(source);

		assertTrue("String1 should be String1", dest.getAttribute("String1", "Missing").equals("String1")); 

		assertTrue("Int1 should be 1", dest.getAttribute("Int1", 0) == 1);

		assertTrue("Boolean1 should be true", dest.getAttribute("Boolean1", false));

		assertTrue("Boolean2 should be false", !dest.getAttribute("Boolean2", true));

	}

	/**

	 * Tests setting a default template in the project scope.

	 * 

	 * @throws CoreException

	 */

	public void testProjectScopeTemplate() throws CoreException {

		ILaunchConfigurationWorkingCopy wc = newConfiguration(null, "test-project-scope");

		ILaunchConfiguration template = wc.doSave();

		ILaunchConfigurationType type = template.getType();

		IScopeContext scope = new ProjectScope(getProject());

		type.setTemplate(template, scope);

		ILaunchConfiguration configuration = type.getTemplate(scope);

		assertNotNull("No template found", configuration);

		assertEquals("Wrong template", template, configuration);

		// test removing scope

		type.setTemplate(null, scope);

		configuration = type.getTemplate(scope);

		assertNull("Should no longer be a template", configuration);

	}

	/**

	 * Tests setting a default template in the project scope.

	 * 

	 * @throws CoreException

	 */

	public void testInstanceScopeTemplate() throws CoreException {

		ILaunchConfigurationWorkingCopy wc = newConfiguration(null, "test-instance-scope");

		ILaunchConfiguration template = wc.doSave();

		ILaunchConfigurationType type = template.getType();

		IScopeContext scope = new InstanceScope();

		type.setTemplate(template, scope);

		ILaunchConfiguration configuration = type.getTemplate(scope);

		assertNotNull("No template found", configuration);

		assertEquals("Wrong template", template, configuration);

		// test removing scope

		type.setTemplate(null, scope);

		configuration = type.getTemplate(scope);

		assertNull("Should no longer be a template", configuration);

	}	

	/**

	 * Tests that a default template in the project scope is used to initialize

	 * values.

	 * 

	 * @throws CoreException

	 */

	public void testCreationFromProjectScopeTemplate() throws CoreException {

		ILaunchConfigurationWorkingCopy pc = newConfiguration(null, "test-project-scope-creation");

		pc.setAttribute("PROJECT", "PROJECT");

		ILaunchConfiguration ptemplate = pc.doSave();

		ILaunchConfigurationWorkingCopy ic = newConfiguration(null, "test-workspace-scope-creation");

		ic.setAttribute("WORKSPACE", "WORKSPACE");

		ILaunchConfiguration itemplate = ic.doSave();

		ILaunchConfigurationType type = ptemplate.getType();

		IScopeContext pscope = new ProjectScope(getProject());

		IScopeContext wscope = new InstanceScope();

		type.setTemplate(ptemplate, pscope);

		type.setTemplate(itemplate, wscope);

		// create a new configuration in project scope priority

		ILaunchConfigurationWorkingCopy config = type.newInstance(null, "test-scopes", new IScopeContext[]{pscope, wscope});

		assertNotNull("Made from wrong template", config.getAttribute("PROJECT", (String)null));

		assertEquals("Should refer to creation template", ptemplate, config.getTemplate());

		// Removing defaults

		type.setTemplate(null, pscope);

		type.setTemplate(null, wscope);

		ILaunchConfiguration configuration = type.getTemplate(pscope);

		assertNull("Should no longer be a project template", configuration);

		configuration = type.getTemplate(wscope);

		assertNull("Should no longer be a workspace template", configuration);

	}	

	/**

	 * Tests that a default template in the instance scope is used to initialize

	 * values.

	 * 

	 * @throws CoreException

	 */

	public void testCreationFromInsatnceScopeTemplate() throws CoreException {

		ILaunchConfigurationWorkingCopy ic = newConfiguration(null, "test-workspace-scope-creation");

		ic.setAttribute("WORKSPACE", "WORKSPACE");

		ILaunchConfiguration itemplate = ic.doSave();

		ILaunchConfigurationType type = itemplate.getType();

		IScopeContext pscope = new ProjectScope(getProject());

		IScopeContext wscope = new InstanceScope();

		type.setTemplate(itemplate, wscope);

		// create a new configuration in project scope priority, but picks up workspace scope

		ILaunchConfigurationWorkingCopy config = type.newInstance(null, "test-scopes", new IScopeContext[]{pscope, wscope});

		assertNotNull("Made from wrong template", config.getAttribute("WORKSPACE", (String)null));

		assertEquals("Should refer to creation template", itemplate, config.getTemplate());

		// Removing defaults

		type.setTemplate(null, wscope);

		ILaunchConfiguration configuration = type.getTemplate(wscope);

		assertNull("Should no longer be a workspace template", configuration);

	}		

	/**

	 * Tests setting the 'isTemplate' attribute.

	 * 

	 * @throws CoreException

	 */

	public void testIsTemplate() throws CoreException {

		ILaunchConfigurationWorkingCopy wc = newConfiguration(null, "test-is-template");

		wc.setTemplate(true);

		ILaunchConfiguration template = wc.doSave();

		assertTrue("Should be a template", template.isTemplate());

		ILaunchConfiguration[] templates = wc.getType().getTemplates();

		assertEquals("Expecting one template", 1, templates.length);

		wc = template.getWorkingCopy();

		wc.setTemplate(false);

		template = wc.doSave();

		assertFalse("Should not be a template", template.isTemplate());

	}

	/**

	 * Tests finding references to a template.

	 * 

	 * @throws CoreException

	 */

	public void testTemplateChildren() throws CoreException {

		ILaunchConfigurationWorkingCopy wc = newConfiguration(null, "test-references");

		ILaunchConfiguration template = wc.doSave();

		ILaunchConfigurationWorkingCopy r1 = newConfiguration(null, "referee-1");

		ILaunchConfigurationWorkingCopy r2 = newConfiguration(null, "referee-2");

		r1.setTemplate(template);

		r2.setTemplate(template);

		ILaunchConfiguration s1 = r1.doSave();

		ILaunchConfiguration s2 = r2.doSave();

		ILaunchConfiguration[] children = template.getTemplateChildren();

		assertEquals("Wrong number of template children", 2, children.length);

		List list = new ArrayList();

		for (int i = 0; i < children.length; i++) {

			list.add(children[i]);		

		}

		assertTrue("Missing reference", list.contains(s1));

		assertTrue("Missing reference", list.contains(s2));

	}