Attachment #52041 for bug #157089

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

View | Details | Raw Unified | Return to bug 157089
Collapse All | Expand All




 **********************************************************************/
package org.eclipse.hyades.test.ui.internal.navigator.proxy;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;


import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.hyades.test.ui.navigator.IFileProxyManager;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;
import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;
import org.eclipse.hyades.test.ui.navigator.ITypeProvider;
import org.eclipse.hyades.test.ui.navigator.ITypeProviderContext;

    private IFileProxyManager fileProxyManager;

    public DefaultTypeProvider() {
        cache = Collections.synchronizedMap(new HashMap()); 
        //- register this class as a resource change listener to the proxy node cache
        FileProxyNodeCache.getInstance().addResourceListener(this);
    }

	}
   
    public void resourceChanged(IResourceChangeEvent event) {
        Object lowestChanged = null;
        IResourceDelta resDelta = event.getDelta();
        //- get all projects affected by the current change
        IResourceDelta[] affectedProjects = resDelta.getAffectedChildren();
        boolean oneProjectAlreadyChanged = false;
        for (int i = 0; i < affectedProjects.length; i++) {
        	Object lowestChanged = null;
            IResourceDelta delta = affectedProjects[i];
            IProject project = (IProject) delta.getResource();
            DefaultTypeProviderProxyNode proxy = (DefaultTypeProviderProxyNode) cache.get(project);
            // proxy may be null if we receive a resource change event before get() is invoked:
            // in this case, there are no proxies to update.
            if (delta.getKind() == IResourceDelta.REMOVED) {
            	cache.remove(project);
            } else if (delta.getKind() == IResourceDelta.CHANGED) {
            	if (proxy == null) {
            		//lowestChanged = project;
            	} else {
	            	int previousChildrenCount = proxy.getChildren().length;
		            lowestChanged = proxy.resourceChanged(delta);
		            if (lowestChanged == proxy) {
						int newChildrenCount = proxy.getChildren().length;
						if ((previousChildrenCount == 0 || newChildrenCount == 0) && previousChildrenCount != newChildrenCount) {
							lowestChanged = project;
						}
					}
            	}
	            if(lowestChanged != null) {
	            	refresher.nodeChanged(lowestChanged);
	            }
            }
            if (lowestTP != null) {
                //- a change is found is it the first one or not ?
                if (lowestChanged == null) {
                    //- that is the first one, save it
                    lowestChanged = lowestTP;
                } else {
                    //- not the first one, so lowest is the parent -> current project
                    if (!oneProjectAlreadyChanged) {
                        lowestChanged = project;
                        oneProjectAlreadyChanged = true;
                    } else {
                        //- this is the second time that a project is changed, lowest is now the root workspace
                        lowestChanged = ResourcesPlugin.getWorkspace().getRoot();
                    }
                }
            }
            if(delta.getKind() == IResourceDelta.REMOVED) {
                cache.remove(project);
            }
        }
        //- refresh only the lowest node
        if(lowestChanged != null) {
            refresher.nodeChanged(lowestChanged);
        }
    }
    




 *******************************************************************************/
package org.eclipse.hyades.test.ui.internal.navigator.proxy;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResourceChangeEvent;

import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.hyades.test.ui.UiPlugin;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.SynchronizedAccess;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;
import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;
import org.eclipse.hyades.test.ui.navigator.ITypeProviderContext;

/** This class manage the extensions of org.eclipse.hyades.test.ui.testNavigatorTestAssetGroupProxy
 *  This class manage all test asset groups created using a cache.

 */
public class TestAssetGroupProxyManager implements IResourceChangeListener {
	
    static class TestAssetInfo extends SynchronizedAccess {
        private String name;
        private boolean isFlat;
        private String imageKey;

        }
    }
    
	private Map extensions;
    /**
     * string -> TestAssetInfo
     */
	private Map extensions;
    /**
     * project -> List(ITestAssetGroupProxyNode)
     */
    private Map cache;
    private IProxyNodeListener refresher;
	
	public TestAssetGroupProxyManager(ITypeProviderContext context) {
		extensions = new HashMap();
        cache = new HashMap();
        refresher = context.getProxyNodeListener();
        refresher = new TestNavigatorRefresher();
		IExtensionPoint extPoint = Platform.getExtensionRegistry().getExtensionPoint(UiPlugin.getID() + ".testNavigatorTestAssetGroupProxy"); //$NON-NLS-1$
		if (extPoint != null) {
			IConfigurationElement[] members = extPoint.getConfigurationElements();

			UiPlugin.logInfo("extension: "+extension+" already registered"); //$NON-NLS-1$ //$NON-NLS-2$			
		}
	}
	
	public Collection getExtensions() {
		return extensions.keySet();
	}
     * @return a list of ITestAssetGroupProxyNode.
     */
    public List getTestAssetGroups(IProject project) {
        if(project != null) {
            List groups = new LinkedList();
            if(cache.containsKey(project)) {
                return (List)cache.get(project);
            } else {
                //- not yet built
                Set keys = extensions.keySet();
                for (Iterator it = keys.iterator(); it.hasNext();) {
                    ITestAssetGroupProxyNode proxy = getTestAssetGroup(project,(String) it.next());
                    if(proxy != null) {
                        groups.add(proxy);
                    }
                }
            }
            return groups;
        } else {
            //- return empty list
            return new LinkedList();
        }
    }
    
    public ITestAssetGroupProxyNode getTestAssetGroup(IProject project, String extension) {
    	ITestAssetGroupProxyNode group = cacheGet(project, extension);
    	if (group == null) {
	        if(extensions.containsKey(extension)) {
	        	//- this extension has a test asset group registered to display those files
	            TestAssetInfo info = (TestAssetInfo)extensions.get(extension);
	            //- build the proxy node with the right parameters
	            try {
	            	if (info.acquireLock(project)) {
	            		// the group may be have been computed in another thread while we
	            		// were acquiring the lock.
	            		group = cacheGet(project, extension);
	            		if (group == null) {
				            group = new TestAssetGroupProxyNode(project, extension, info.getName(), info.getImageKey(), info.isFlat, project);
				            cachePut(project, extension, group);
	            		}
	            	}
	            } finally {
	            	info.releaseLock(project);
	            }
	        }
    	}
    	
    	if(group != null && group.getChildren().length > 0) {
    		return group;
    	}
        return null;
    }

    private void cachePut(IProject project, String extension, ITestAssetGroupProxyNode testAsset) {
    	Map map = (Map) cache.get(project);
    	if (map == null) {
    		map = new HashMap();
    		cache.put(project, map);
    	}
    	map.put(extension, testAsset);
    }
    
    private ITestAssetGroupProxyNode cacheGet(IProject project, String extension) {
    	Map map = (Map) cache.get(project);
    	if (map != null) {
    		ITestAssetGroupProxyNode group = (ITestAssetGroupProxyNode) map.get(extension);
    		if (group != null) return group;
    	}
    	return null;
    }

    /* (non-Javadoc)

            IResourceDelta delta = affectedProjects[i];
            IProject project = (IProject)delta.getResource();
            //- given a project we need to update all test asset group proxy nodes created in this project
            Map groups = (Map)cache.get(project);
            if(groups != null) {
                for (Iterator it = extensions.keySet().iterator(); it.hasNext();) {
                	String ext = (String)it.next();
                    TestAssetGroupProxyNode proxy = (TestAssetGroupProxyNode) groups.get(ext);
                    if (proxy != null) {
	                    IProxyNode lowestProxy = proxy.resourceChanged(delta);
	                    if(proxy.getChildren().length == 0) {
	                        //- this means that the group no longer contains children
	                        lowestChanged = project;
	                        lowestProxy = null;
	                    }
	                    if(lowestProxy != null) {
	                        //- there was a change in this test asset group proxy node tree
	                        if(lowestChanged == null) {
	                            //- this was the first change
	                            lowestChanged = lowestProxy;
	                        } else {
	                            //- the second one ... we need to refresh the owner of those nodes (the project)
	                            lowestChanged = project;
	                        }
	                    }
                    }
                }
            }
            //- we need to handle test asset creation in empty group
            boolean newTAG = getAddedTestAssetGroups(project, delta);
            if(!(lowestChanged instanceof IProject) && newTAG) {
                lowestChanged = project;
            }
        }
        //- after the for loop, we can update the cache for removes
        completeCacheRemoves();
        //- refresh only the lowest node
        if(lowestChanged != null) {
            refresher.nodeChanged(lowestChanged);
        }
    }

    /** Return whether the given project has changed by addition of new test asset group found in the resource delta.
     * @param project the project affected by the resource change
     * @param delta the resource change delta used to know what the change is.
     * @return <code>true</code> if the project has at least one new test asset group proxy node and <code>false</code> otherwise.
     */
    private boolean getAddedTestAssetGroups(IProject project, IResourceDelta delta) {
        List groups = (List)cache.get(project);
        List notExistingExt = new LinkedList();
        //- initializing with all extensions
        for (Iterator it = extensions.keySet().iterator(); it.hasNext();) {
            notExistingExt.add(it.next());
        }
        //- remove from all those that already been handled by a test asset group proxy node
        if(groups != null) {
            for (Iterator it = groups.iterator(); it.hasNext();) {
                TestAssetGroupProxyNode tagpn = (TestAssetGroupProxyNode) it.next();
                notExistingExt.remove(tagpn.getExtension());
            }
        }
        boolean projectChanged = false;
        //- then try to create a test asset group from this list of not yet handled extension 
        for (Iterator it = notExistingExt.iterator(); it.hasNext();) {
            String ext = (String) it.next();
            ITestAssetGroupProxyNode proxy = getTestAssetGroup(project, ext);
            //- if the proxy has been created, that means that the project need to be refreshed
            if(proxy != null) {
                projectChanged  = true;
            }
        }
        return projectChanged;
    }

    private void prepareCacheRemove(IProject project, TestAssetGroupProxyNode proxy) {
        List proxies;
        if(removedElements.containsKey(project)) {
            //- a test asset group of this project has already been added to removals
            proxies = (List)removedElements.get(project);
        } else {
            proxies = new LinkedList();
            removedElements.put(project, proxies);
        }
        proxies.add(proxy);
    }

    private void completeCacheRemoves() {
        Set removed = removedElements.entrySet();
        for (Iterator it = removed.iterator(); it.hasNext();) {
            Map.Entry element = (Map.Entry) it.next();
            IProject project = (IProject)element.getKey();
            //- remove saved test asset groups of this project
            removeCacheElements(project, (List)element.getValue());
        }
        //- clear removal cache.
        removedElements.clear();
    }

    /**
     * Removes all element given by the list argument from the project cached elements
     * @param project the project from which the elements are removed
     * @param list elments to remove. (those elements should be ITestAssetGroupProxyNode)
     */
    private void removeCacheElements(IProject project, List list) {
        List groups = (List)cache.get(project);
        for(Iterator it = list.iterator(); it.hasNext(); ) {
            groups.remove(it.next());
        }
    }
    
    public void dispose() {
        FileProxyNodeCache.getInstance().removeResourceListener(this);
    }




package org.eclipse.hyades.test.ui.internal.navigator.proxy;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;

import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;

import org.eclipse.hyades.test.ui.UiPlugin;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigatorMessages;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.SynchronizedAccess;
import org.eclipse.hyades.test.ui.navigator.FileProxyNode;
import org.eclipse.hyades.test.ui.navigator.IFileProxyFactory;
import org.eclipse.hyades.test.ui.navigator.IPersistableProxyNode;

 * @author jgout
 * @since 4.2
 */
public class FileProxyNodeCache extends SynchronizedAccess {

    /**
     * Internal class associated to files that do not have a proxy. It is used as a marker

    private IFileProxyPersister defaultPersister = new FileProxyMarkerPersister();
    
    /**
     * The set of locked files. A file is locked when a proxy is being computed for this
     * file. Only one thread is allowed to access a file at one time.
     */
    private Collection locks = Collections.synchronizedList(new ArrayList(TestNavigator.BACKGROUND_JOB_POOL_SIZE + 1));
    
    /**
     * Singleton instance.
     */
    private static FileProxyNodeCache instance;

    	IProxyNode proxy = (IProxyNode) proxies.get(file);
        if (proxy == null && file.exists()) {
	    	try {
	    		if (acquireLock(file)) {
		    		// Test again if file is in the map. It may have been added while we were
		    		// acquiring the lock.
		    		proxy = (IProxyNode) proxies.get(file);
		    		if (proxy == null) {
			            //- not yet in the cache, try to load it.
			            proxy = loadProxy(file);
			            if(proxy == null) {
			                //- load failed, create the proxy using a proxy factory.
			                proxy = internalCreateProxy(file);
			            }
		    		}
	    		}
	    	} catch (Throwable t) {
	    		proxy = createErrorProxy(file, t);
	    	} finally {
	    		releaseLock(file);
	    	}
        }
        if (proxy == nullProxy) return null;

     * @return the new proxy node ot <code>null</code> if there is no factory that is able to create proxies from this kind of file. 
     */
    public IProxyNode createProxy(IFile file) {
    	try {
    		if (acquireLock(file)) {
	    		proxies.remove(file);
	    		return internalCreateProxy(file);
    		} else {
    			return null;
    		}
    	} finally {
    		releaseLock(file);
    	}
    }
    
    private IProxyNode internalCreateProxy(IFile file) {
        IProxyNode proxy = null;
        //- get all factories (FileProxyFactory) for this file element
        ArrayList factories = TestNavigator.getFileFactoryManager().getFactories(file.getFileExtension());

		resourceListeners.remove(listener);
    }
    
    /**
     * Invoked when a project is closed. This method cleans up the map and removes any
     * cached files that belong the closed project.
     * @param project
     */
    protected void projectClosed(IProject project) {
    	for (Iterator it = proxies.keySet().iterator(); it.hasNext();) {
			IFile file = (IFile) it.next();
			if (project.equals(file.getProject())) {
				it.remove();
			}
		}
    }
    
    private class ResourceChangeListener implements IResourceChangeListener, IResourceDeltaVisitor {

    	public ResourceChangeListener() {

		    IResourceDelta delta = event.getDelta();
            if(delta == null) return;
            //- first delegates to other listeners registered in the cache.
            IResourceChangeListener[] copy;
            synchronized(resourceListeners) {
            	copy = (IResourceChangeListener[]) resourceListeners.toArray(new IResourceChangeListener[resourceListeners.size()]);
            }
            for (int i = 0; i < copy.length; i++) {
                try {
                    copy[i].resourceChanged(event);
                } catch (Throwable e) {
                    UiPlugin.logError(e);
                }                
            }
            //- then cache can handle proxies removal properly.
			try {


		public boolean visit(IResourceDelta delta) throws CoreException {
			if (delta.getKind() == IResourceDelta.CHANGED) {
				if (delta.getResource().getType() == IResource.PROJECT) {
					if ((delta.getFlags() & IResourceDelta.OPEN) != 0) {
						IProject project = (IProject)delta.getResource();
						if (!project.isOpen()) {
							// Project has been closed.
							projectClosed(project);
						}
					}
				}
				return delta.getResource().getType() != IResource.FILE;
			}
			if (delta.getKind() == IResourceDelta.REMOVED) {

			return false;
		}
    }
    
}

Lines 11-16 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/proxy/TypeProviderManager.java (-9 / +22 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.hyades.test.ui.internal.navigator.proxy;	12	package org.eclipse.hyades.test.ui.internal.navigator.proxy;
13		13
		14	import java.util.Collections;
14	import java.util.HashMap;	15	import java.util.HashMap;
15	import java.util.Iterator;	16	import java.util.Iterator;
16	import java.util.Map;	17	import java.util.Map;
Lines 22-27 Link Here
22	import org.eclipse.core.runtime.Platform;	23	import org.eclipse.core.runtime.Platform;
23	import org.eclipse.hyades.test.ui.UiPlugin;	24	import org.eclipse.hyades.test.ui.UiPlugin;
24	import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;	25	import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
		26	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.ISynchronizedAccess;
		27	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.JobSynchronizedAccess;
25	import org.eclipse.hyades.test.ui.navigator.ITypeProvider;	28	import org.eclipse.hyades.test.ui.navigator.ITypeProvider;
26	import org.eclipse.hyades.test.ui.navigator.ITypeProviderContext;	29	import org.eclipse.hyades.test.ui.navigator.ITypeProviderContext;
27	import org.eclipse.hyades.test.ui.navigator.ITypeProviderProxyNode;	30	import org.eclipse.hyades.test.ui.navigator.ITypeProviderProxyNode;
Lines 37-43 Link Here
37	*/	40	*/
38	public class TypeProviderManager {	41	public class TypeProviderManager {
39		42
40	static interface ITypeProviderInfo {	43	static interface ITypeProviderInfo extends ISynchronizedAccess {
41		44
42	/**	45	/**
43	* @return Returns the imageKey.	46	* @return Returns the imageKey.
Lines 56-62 Link Here
56		59
57	}	60	}
58		61
59	class ExtensionTypeProviderInfo implements ITypeProviderInfo {	62	class ExtensionTypeProviderInfo extends JobSynchronizedAccess implements ITypeProviderInfo {
60	private String name;	63	private String name;
61	private String imageKey;	64	private String imageKey;
62	/**	65	/**
Lines 103-109 Link Here
103	}	106	}
104	}	107	}
105		108
106	class DefaultTypeProviderInfo implements ITypeProviderInfo {	109	class DefaultTypeProviderInfo extends JobSynchronizedAccess implements ITypeProviderInfo {
107	private DefaultTypeProvider defaultTypeProvider;	110	private DefaultTypeProvider defaultTypeProvider;
108	private String name;	111	private String name;
109		112
Lines 137-143 Link Here
137	private ITypeProviderContext context;	140	private ITypeProviderContext context;
138		141
139	public TypeProviderManager(ITypeProviderContext context) {	142	public TypeProviderManager(ITypeProviderContext context) {
140	providers = new HashMap();	143	providers = Collections.synchronizedMap(new HashMap());
141	this.context = context;	144	this.context = context;
142	IExtensionPoint extPoint = Platform.getExtensionRegistry().getExtensionPoint(UiPlugin.getID() + ".testNavigatorTypeProvider"); //$NON-NLS-1$	145	IExtensionPoint extPoint = Platform.getExtensionRegistry().getExtensionPoint(UiPlugin.getID() + ".testNavigatorTypeProvider"); //$NON-NLS-1$
143	if (extPoint != null) {	146	if (extPoint != null) {
Lines 178-191 Link Here
178	* @return a type provider proxy node.	181	* @return a type provider proxy node.
179	*/	182	*/
180	public ITypeProviderProxyNode getTypeProviderProxyNode(IProject project, String type) {	183	public ITypeProviderProxyNode getTypeProviderProxyNode(IProject project, String type) {
181	if(!providers.containsKey(type)) {	184	synchronized(providers) {
182	//- since no provider registered for the given type, add the default one for the given type in the map	185	if(!providers.containsKey(type)) {
183	addProvider(type, new DefaultTypeProviderInfo(type));	186	//- since no provider registered for the given type, add the default one for the given type in the map
184	}	187	addProvider(type, new DefaultTypeProviderInfo(type));
		188	}
		189	}
185	//- By construction, the internal map of providers has a provider for the given type.	190	//- By construction, the internal map of providers has a provider for the given type.
186	ITypeProviderInfo info = (ITypeProviderInfo)providers.get(type);	191	ITypeProviderInfo info = (ITypeProviderInfo)providers.get(type);
187	//- deleguate to client	192	//- deleguate to client
188	return info.getProvider().get(project, type);	193	ITypeProvider provider = info.getProvider();
		194	try {
		195	if (info.acquireLock(project)) {
		196	return provider.get(project, type);
		197	}
		198	return null;
		199	} finally {
		200	info.releaseLock(project);
		201	}
189	}	202	}
190		203
191	/** Returns the name registered in the extension for the given type of element.	204	/** Returns the name registered in the extension for the given type of element.

Lines 11-16 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/proxy/FileProxyManager.java (-2 / +3 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.hyades.test.ui.internal.navigator.proxy;	12	package org.eclipse.hyades.test.ui.internal.navigator.proxy;
13		13
		14	import java.util.Collections;
14	import java.util.HashMap;	15	import java.util.HashMap;
15	import java.util.Iterator;	16	import java.util.Iterator;
16	import java.util.Map;	17	import java.util.Map;
Lines 43-50 Link Here
43	private FileProxyNodeCache fileProxyNodeCache;	44	private FileProxyNodeCache fileProxyNodeCache;
44		45
45	public FileProxyManager() {	46	public FileProxyManager() {
46	parents = new HashMap();	47	parents = Collections.synchronizedMap(new HashMap());
47	parentsToCache = new HashMap();	48	parentsToCache = Collections.synchronizedMap(new HashMap());
48	fileProxyNodeCache = FileProxyNodeCache.getInstance();	49	fileProxyNodeCache = FileProxyNodeCache.getInstance();
49	}	50	}
50		51




/*******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: TestNavigatorRefresher.java,v 1.2 2005/04/26 15:55:53 jcanches Exp $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.hyades.test.ui.internal.navigator.proxy;

import java.util.Iterator;

import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;

/**
 * @author jgout
 *
 */
public class TestNavigatorRefresher implements IProxyNodeListener {

    public void nodeChanged(Object node) {
        for(Iterator it = TestNavigator.getAllInstancesIterator(); it.hasNext();) {
            ((TestNavigator)it.next()).nodeChanged(node);
        }
    }

}





import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;
import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;

/**
 * @author jgout
 * @author jcanches
 */
public abstract class TestNavigatorProvider extends TestNavigatorLabelProvider implements ITreeContentProvider {

	public static final int CONTEXT_LOADING = 0;
	public static final int CONTEXT_INTERACTIVE = 1;
	
	protected TestNavigator testNavigator;
	private int context;

	public TestNavigatorProvider(TestNavigator testNavigator) {
		this.testNavigator = testNavigator;
		this.context = CONTEXT_LOADING;
	}

	protected abstract IProxyNodeListener getProxyNodeListener();
	
	public Object getParent(Object element) {
		if (element instanceof IProxyNode) {
            Object parent = ((IProxyNode) element).getParent();

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	}

	/**
	 * Sets the context in which the provider is used. There are two available values:
	 * INTERACTIVE and LOADING. The context has an effect on two parameters:
	 * 1) responsiveness: time that getChildren() is allowed to spent before returning
	 * control. High responsiveness means that the provider will return incomplete nodes,
	 * compute the remaining in a background task, and update the navigator when computation
	 * is complete. Low responsiveness means that the UI will be blocked for a longer period of
	 * time but the returned node are more likely to be complete.
	 * 2) computation job priority: the priority allocated to the computation job, if the provider
	 * does not manage to compute nodes in the allocated time (responsiveness parameter). This does
	 * not affect the thread priority, but helps eclipse decide which job should be launched first.
	 * In LOADING mode, responsiveness is high (100ms) and priority is low (NORMAL).
	 * In INTERACTIVE mode, responsiveness is lower (800ms) and priority is high (INTERACTIVE).
	 */
	public void setContext(int context) {
		this.context = context;
	}
	
	protected int getContext() {
		return context;
	}
	
	protected int getResponseTime() {
		switch (context) {
		case CONTEXT_INTERACTIVE:
			return 800;
		case CONTEXT_LOADING:
			return 100;
		}
		return 100;
	}
	
	protected int getJobPriority() {
		switch(context) {
		case CONTEXT_INTERACTIVE:
			return Job.INTERACTIVE;
		case CONTEXT_LOADING:
			return Job.LONG;
		}
		return Job.LONG;
	}
}

Lines 15-20 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/messages.properties (+6 lines)
15		15
16	TEST_NAVIGATOR_UNNAMED_ELEMENT=unnamed	16	TEST_NAVIGATOR_UNNAMED_ELEMENT=unnamed
17	PROXY_LOADING_ERROR=loading error	17	PROXY_LOADING_ERROR=loading error
		18	NODE_PENDING=Pending...
18	OpenWithActionGroup_ActionLabel=Open Wit&h	19	OpenWithActionGroup_ActionLabel=Open Wit&h
19	FileFolderInContainerPaste_NameTwoArg=Copy ({0}) of {1}	20	FileFolderInContainerPaste_NameTwoArg=Copy ({0}) of {1}
20	FileFolderInContainerPaste_NameOneArg=Copy of {0}	21	FileFolderInContainerPaste_NameOneArg=Copy of {0}
Lines 24-26 Link Here
24	FileFolderInContainerPaste_MessageLabel=Enter a new name for ''{0}''	25	FileFolderInContainerPaste_MessageLabel=Enter a new name for ''{0}''
25	TestNavigatorActionGroup_ToggleAction_Text=Link with Editor	26	TestNavigatorActionGroup_ToggleAction_Text=Link with Editor
26	RenameAction_ActionName=Rena&me	27	RenameAction_ActionName=Rena&me
		28	PM_INDEXING_TYPE=Indexing type {0}
		29	PM_INDEXING_ASSET_GROUP=Indexing .{0} assets
		30	PM_EXPLORING_PROJECT=Exploring project {0}
		31	PM_EXPLORING_FOLDER=Exploring {0}
		32	PM_INDEXING_FILE=Indexing {0}

Lines 11-27 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/ResourceTestNavigatorProvider.java (-10 / +117 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.hyades.test.ui.internal.navigator;	12	package org.eclipse.hyades.test.ui.internal.navigator;
13		13
		14	import java.util.ArrayList;
		15	import java.util.Collections;
		16	import java.util.HashMap;
		17	import java.util.Iterator;
14	import java.util.List;	18	import java.util.List;
		19	import java.util.Map;
15		20
16	import org.eclipse.core.resources.IContainer;	21	import org.eclipse.core.resources.IContainer;
17	import org.eclipse.core.resources.IFile;	22	import org.eclipse.core.resources.IFile;
18	import org.eclipse.core.resources.IProject;	23	import org.eclipse.core.resources.IProject;
19	import org.eclipse.core.resources.IResource;	24	import org.eclipse.core.resources.IResource;
20	import org.eclipse.core.runtime.CoreException;	25	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.emf.common.util.UniqueEList;
22	import org.eclipse.hyades.test.ui.UiPlugin;	26	import org.eclipse.hyades.test.ui.UiPlugin;
23	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;	27	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;
		28	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.FileProxiesRequest;
		29	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.IProxiesRequestListener;
		30	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.ProxiesRequest;
24	import org.eclipse.hyades.test.ui.navigator.IProxyNode;	31	import org.eclipse.hyades.test.ui.navigator.IProxyNode;
		32	import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;
		33	import org.eclipse.hyades.ui.util.IDisposable;
25		34
26	/** This the resource oriented provider for the test navigator view.	35	/** This the resource oriented provider for the test navigator view.
27	* @author jgout	36	* @author jgout
Lines 39-44 Link Here
39	return fileProxyManager;	48	return fileProxyManager;
40	}	49	}
41		50
		51	public ResourceTestNavigatorProvider(TestNavigator testNavigator) {
		52	super(testNavigator);
		53	}
		54
		55	private FileProxyRequests requests = new FileProxyRequests();
		56
42	public Object getParent(Object element) {	57	public Object getParent(Object element) {
43	if (element instanceof IResource) {	58	if (element instanceof IResource) {
44	return ((IResource) element).getParent();	59	return ((IResource) element).getParent();
Lines 101-107 Link Here
101	* @return an array of Object which cn be empty but not null	116	* @return an array of Object which cn be empty but not null
102	*/	117	*/
103	private Object[] getContainerChildren(Object parentElement) {	118	private Object[] getContainerChildren(Object parentElement) {
104	List children = new UniqueEList();
105	IResource[] resources = null;	119	IResource[] resources = null;
106	IContainer container = ((IContainer) parentElement);	120	IContainer container = ((IContainer) parentElement);
107	if (container.isAccessible()) {	121	if (container.isAccessible()) {
Lines 111-133 Link Here
111	UiPlugin.logError(e);	125	UiPlugin.logError(e);
112	return new Object[0];	126	return new Object[0];
113	}	127	}
		128	List children = new ArrayList(resources.length);
		129	FileProxiesRequest request = requests.getRequest(container, resources);
114	for (int i = 0, maxi = resources.length; i < maxi; i++) {	130	for (int i = 0, maxi = resources.length; i < maxi; i++) {
115	if (!TestNavigator.getFiltersManager().filter(resources[i])) {	131	if (!TestNavigator.getFiltersManager().filter(resources[i])) {
116	if (resources[i].getType() != IResource.FILE) {	132	if (resources[i].getType() != IResource.FILE) {
117	//- folders are displayed as they are	133	children.add(resources[i]);
118	children.add(resources[i]);	134	} else {
119	} else {
120	//- convert the file in something else (proxy)	135	//- convert the file in something else (proxy)
121	IProxyNode node = fileProxyManager.getProxy((IFile) resources[i], resources[i].getParent());	136	IFile file = (IFile)resources[i];
		137	IProxyNode node = request.getProxy(file);
122	if (!TestNavigator.getFiltersManager().filter(node)) {	138	if (!TestNavigator.getFiltersManager().filter(node)) {
123	children.add(node);	139	children.add(node);
124	fileProxyManager.cacheProxy((IFile) resources[i], node);	140	fileProxyManager.cacheProxy(file, node);
125	}	141	}
126	}	142	}
127	}	143	}
128	}	144	}
129	}	145	return children.toArray();
130	return children.toArray();	146	}
		147	return new Object[0];
		148	}
		149
		150	public IProxyNodeListener getProxyNodeListener() {
		151	return requests;
		152	}
		153
		154	private class FileProxyRequests implements IProxiesRequestListener, IDisposable, IProxyNodeListener {
		155
		156	private Map containerToRequestMap = Collections.synchronizedMap(new HashMap());
		157
		158	public FileProxiesRequest getRequest(IContainer container, IResource[] members) {
		159	FileProxiesRequest request = (FileProxiesRequest)containerToRequestMap.get(container);
		160	//if (request != null && !request.isPending()) containerToRequestMap.remove(container);
		161	if (request == null) {
		162	request = newRequest(container, members);
		163	}
		164	return request;
		165	}
		166
		167	public FileProxiesRequest newRequest(IContainer container, IResource[] members) {
		168	ArrayList filesToRequest = new ArrayList(members.length);
		169	for (int i = 0, maxi = members.length; i < maxi; i++) {
		170	if (members[i].getType() == IResource.FILE) {
		171	if (!TestNavigator.getFiltersManager().filter(members[i])) {
		172	filesToRequest.add(members[i]);
		173	}
		174	}
		175	}
		176	if (filesToRequest.isEmpty()) return null;
		177	FileProxiesRequest req = new FileProxiesRequest(filesToRequest, fileProxyManager, container, testNavigator);
		178	req.setPriority(getJobPriority());
		179	testNavigator.getJobPool().scheduleJob(req);
		180	if (!req.wait(getResponseTime(), this, 2000)) {
		181	containerToRequestMap.put(container, req);
		182	}
		183	return req;
		184	}
		185
		186	public void proxyComputed(final ProxiesRequest request, Object key) {
		187	}
		188
		189	public void computationCompleted(ProxiesRequest request) {
		190	IContainer parent = ((FileProxiesRequest)request).getParent();
		191	if (containerToRequestMap.containsKey(parent)) {
		192	// A last refresh is necessary to remove the request from the map.
		193	testNavigator.refresh(parent);
		194	}
		195	}
		196
		197	public void dispose() {
		198	// Cancel all running requests. As the atomic action of FileProxiesRequest is
		199	// the computation of a single file proxy, all requests should honor the cancel
		200	// request quite quickly. However we don't wait them to complete (i.e. they may
		201	// be still running while this instance has been disposed).
		202	for (Iterator it = containerToRequestMap.values().iterator(); it.hasNext();) {
		203	FileProxiesRequest request = (FileProxiesRequest) it.next();
		204	request.dispose();
		205	it.remove();
		206	}
		207	}
		208
		209	public void proxiesComputed(ProxiesRequest request) {
		210	testNavigator.refresh(((FileProxiesRequest)request).getParent());
211	}
212
213	public void nodeChanged(Object node) {
214	if (node instanceof IContainer) {
215	FileProxiesRequest req = (FileProxiesRequest) containerToRequestMap.remove(node);
216	if (req != null) {
217	// Then we need to cancel the current request. A new one will be spawned
218	// when getChildren() is invoked on this project.
219	if (req.cancel(1000)) {
220	containerToRequestMap.remove(node);
221	testNavigator.refresh(node);
222	}
223	}
224	}
225	}
226
227	public void computationCancelled(ProxiesRequest request) {
228	IContainer parent = ((FileProxiesRequest)request).getParent();
229	containerToRequestMap.remove(parent);
230	testNavigator.refresh(parent);
231	}
232
233	}
234
235	public void dispose() {
236	requests.dispose();
237	super.dispose();
131	}	238	}
132		239
133	}	240	}




import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.emf.common.util.UniqueEList;

import org.eclipse.hyades.models.common.common.CMNNamedElement;
import org.eclipse.hyades.test.core.util.EMFUtil;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyNodeCache;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;
import org.eclipse.hyades.ui.internal.provider.IResourceChangeUpdater;
import org.eclipse.jface.viewers.IStructuredSelection;

						addedObjects.add(affectedResources[i]);
					}
				} else {
					// Don't bother computing the proxy here, since this may be long.
					// Refresh the container so its children are re-computed and the added
					// file gets discovered (the discovery will happen in a background job,
					// which is much better).
					IContainer container = affectedResources[i].getParent();
					changedObjects.add(container);
                        TestNavigator.getFileProxyManager().cacheProxy((IFile)affectedResources[i], convertedObject);
					}
				}
			}
		} else {

					//- in case of file removed, we need to find the right corresponding element in the test navigator
					//- try to retrieve a proxy from this file
					//- the object to remove from the navigator is the proxy
					IProxyNode proxy = FileProxyNodeCache.getInstance().getCachedProxy((IFile)affectedResources[i]);
					if(proxy != null) {
						removedObjects.add(proxy);
					}




import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyNodeCache;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.TestAssetGroupProxyManager;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.TestNavigatorRefresher;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.TypeProviderManager;
import org.eclipse.hyades.test.ui.internal.util.ContextIds;
import org.eclipse.hyades.test.ui.internal.util.FixedSizeJobPool;
import org.eclipse.hyades.test.ui.navigator.CMNNamedElementProxyNode;
import org.eclipse.hyades.test.ui.navigator.EObjectProxyNode;
import org.eclipse.hyades.test.ui.navigator.FileProxyNode;


    public static final int VIEW_ID_LOGICAL = 1;

    /**
     * The size of the background job pool. This is the maximal number of background
     * jobs that can run at the same time.
     */
    public static final int BACKGROUND_JOB_POOL_SIZE = 3;
   
    private int currentViewIndex;

    /**

    /** actions to switch between both logical and resource views. */
    private ToggleViewAction[] viewActions;

    /** Current content and label provider. */
    private TestNavigatorProvider currentProvider;

    // - constants are used in the IDialogSettings
    protected final static String SET_SHOW_FOLDERS = "SHOW_FOLDERS"; //$NON-NLS-1$

    protected final static int CP_FOLDER = 0;

    protected final static int CP_LOGICAL = 1;
    
    private List rootLogicalFolders;

    private boolean showingFolders = true;

    private boolean showingEObjectChildren = true;

    private ResourceChangeUpdaterProvider resourceChangeUpdaterProvider;
    
    private FixedSizeJobPool jobPool;
    
    /**
     * Constructor for TestNavigator
     */

        super(ITestNavigator.ID);

        viewActions = new ToggleViewAction[] { new ToggleViewAction(this, VIEW_ID_RESOURCE), new ToggleViewAction(this, VIEW_ID_LOGICAL) };
        providers = new TestNavigatorProvider[] { new ResourceTestNavigatorProvider(), new LogicalTestNavigatorProvider() };
    }

    /**

    /**
     * @return Returns the typeProviderProxyManager.
     */
    public synchronized static TypeProviderManager getTypeProviderManager() {
        if (typeProviderManager == null) {
            typeProviderManager = new TypeProviderManager(getTypeProviderContext());
        }
        return typeProviderManager;
    }
    
    private static class AllInstancesRefresher implements IProxyNodeListener {
        public void nodeChanged(Object node) {
            for(Iterator it = TestNavigator.getAllInstancesIterator(); it.hasNext();) {
                ((TestNavigator)it.next()).nodeChanged(node);
            }
        }
    }
    
    /**
     * This class is responsible to give the correct context to the used ITypeProvider (DefaultTypeProvider).
     * It stores the file proxy manager of the logical view to be used by the ITypeProvider,

        }
		public IProxyNodeListener getProxyNodeListener() {
			if (refresher == null) {
				refresher = new AllInstancesRefresher();
			}
			return refresher;
		}

    	return typeProviderContext;
    }

    public synchronized static TestAssetGroupProxyManager getTestAssetGroupProxyManager() {
        if (testAssetGroupProxyManager == null) {
            testAssetGroupProxyManager = new TestAssetGroupProxyManager(getTypeProviderContext());
        }
        return testAssetGroupProxyManager;
    }

     * @see org.eclipse.ui.IWorkbenchPart#dispose()
     */
    public void dispose() {
    	if (jobPool != null) {
    		// Disposing the job pool cancels all pending jobs that have net been yet
    		// scheduled.
    		jobPool.dispose();
    	}
    	// Cancel all "TestNavigatorJob"s, i.e. jobs that belongs the "family" represented by
    	// this instance. This cancels all jobs that have already been scheduled.
    	Platform.getJobManager().cancel(this);
    	
        if (rootLogicalFolders != null)
            rootLogicalFolders.clear();
        removeTestNavigator(this);

        resourceChangeUpdaterProvider.dispose();
        resourceChangeUpdaterProvider = null;

        for (int i = 0; i < providers.length; i++) {
            if(providers[i] != null){
                providers[i].dispose();
                providers[i] = null;
            }
        }
        
        if(testAssetGroupProxyManager != null){
            testAssetGroupProxyManager.dispose();
            testAssetGroupProxyManager=null;

        addTestNavigator(this);
    }

    private void adjustCurrentProviderContext(boolean isLoading) {
		if (currentProvider != null) {
			if (isLoading) {
				currentProvider.setContext(TestNavigatorProvider.CONTEXT_LOADING);
			} else {
				currentProvider.setContext(TestNavigatorProvider.CONTEXT_INTERACTIVE);
			}
		}
	}

	/**
     * Returns the file associated to a given object that is located in this
     * navigator.
     * 

        };
        treeViewer.addFilter(viewerFilter);

        resourceChangeUpdaterProvider = new ResourceChangeUpdaterProvider.UIUpdaterProvider(false);
        FileProxyNodeCache.getInstance().addResourceListener(resourceChangeUpdaterProvider);
        IResourceChangeUpdater resourceChangeUpdater = new TestResourceChangeUpdater(this);
        resourceChangeUpdaterProvider.setResourceChangeUpdater(resourceChangeUpdater);

     * @param treeViewer
     */
    private void updateTestNavigatorProvider(TreeViewer treeViewer) {
    	if (currentViewIndex == VIEW_ID_RESOURCE) {
    		currentProvider = new ResourceTestNavigatorProvider(this);
    	} else {
    		currentProvider = new LogicalTestNavigatorProvider(this);
    	}
    	adjustCurrentProviderContext(true);
        treeViewer.setContentProvider(currentProvider);
        ILabelDecorator decorator = PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator();
        ILabelProvider labelProvider = new TestDecoratingLabelProvider(currentProvider, decorator, this); 
        treeViewer.setLabelProvider(labelProvider);
        adjustCurrentProviderContext(false);
    }

    /**

        if (input instanceof IFileEditorInput) {
            IFileEditorInput fileInput = (IFileEditorInput) input;
            IFile file = fileInput.getFile();
            selectReveal(new StructuredSelection(file));
            return true;
            if ((resource != null) && (!resource.getContents().isEmpty())) {
                IStructuredSelection structuredSelection = getStructuredSelection();
                if (structuredSelection.size() == 1) {
                    Object currentSelection = structuredSelection.getFirstElement();
                    if (currentSelection instanceof EObject) {
                        if (((EObject) currentSelection).eResource() == resource)
                            return true;
                    }
                }

                selectReveal(new StructuredSelection(resource.getContents().get(0)));
                return true;
            }
        }

        return false;

        }
    }

    /**
     * Invoked by test providers to notify that a node and its children should be refreshed.
     */
    public void nodeChanged(Object node) {
    	currentProvider.getProxyNodeListener().nodeChanged(node);
        refresh(node);
    }
    
    /**
     * Internal method used by the provider to refresh a node and its sub-nodes. The difference
     * with nodeChanged(Object) is that this method does not notify the provider with the change.
     * @param node
     */
    /*package*/void refresh(Object node) {
    	Display.getDefault().asyncExec(new Refresher(node));
    }
    
    /**
     * @return
     */

            return "[Invalid Descriptor]"; //$NON-NLS-1$ 
        }
    }

	public FixedSizeJobPool getJobPool() {
		if (jobPool == null) {
			 jobPool = new FixedSizeJobPool(BACKGROUND_JOB_POOL_SIZE);
		}
		return jobPool;
	}
}

Lines 11-30 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/LogicalTestNavigatorProvider.java (-16 / +172 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.hyades.test.ui.internal.navigator;	12	package org.eclipse.hyades.test.ui.internal.navigator;
13		13
		14	import java.util.ArrayList;
		15	import java.util.Collection;
		16	import java.util.HashMap;
14	import java.util.Iterator;	17	import java.util.Iterator;
15	import java.util.LinkedList;
16	import java.util.List;	18	import java.util.List;
		19	import java.util.Map;
17		20
18	import org.eclipse.core.resources.IProject;	21	import org.eclipse.core.resources.IProject;
		22	import org.eclipse.core.resources.IResource;
19	import org.eclipse.hyades.test.ui.TestUIExtension;	23	import org.eclipse.hyades.test.ui.TestUIExtension;
20	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;	24	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;
		25	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.IProxiesRequestListener;
		26	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.LogicalProjectProxiesRequest;
		27	import org.eclipse.hyades.test.ui.internal.navigator.proxy.async.ProxiesRequest;
21	import org.eclipse.hyades.test.ui.navigator.IFileProxyManager;	28	import org.eclipse.hyades.test.ui.navigator.IFileProxyManager;
22	import org.eclipse.hyades.test.ui.navigator.IProxyNode;	29	import org.eclipse.hyades.test.ui.navigator.IProxyNode;
23	import org.eclipse.hyades.test.ui.navigator.ITypeProviderProxyNode;	30	import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;
24	import org.eclipse.hyades.ui.extension.IAssociationConstants;	31	import org.eclipse.hyades.ui.extension.IAssociationConstants;
25	import org.eclipse.hyades.ui.extension.IAssociationDescriptor;	32	import org.eclipse.hyades.ui.extension.IAssociationDescriptor;
26	import org.eclipse.hyades.ui.extension.IAssociationMapping;	33	import org.eclipse.hyades.ui.extension.IAssociationMapping;
27	import org.eclipse.hyades.ui.internal.extension.AssociationMappingRegistry;	34	import org.eclipse.hyades.ui.internal.extension.AssociationMappingRegistry;
		35	import org.eclipse.hyades.ui.util.IDisposable;
		36	import org.eclipse.swt.graphics.Image;
28		37
29	/** This is the provider of the logical test navigator.	38	/** This is the provider of the logical test navigator.
30	* @author jgout	39	* @author jgout
Lines 35-40 Link Here
35	/** The file proxy manager to acces to proxies from files */	44	/** The file proxy manager to acces to proxies from files */
36	private static FileProxyManager fileProxyManager = new FileProxyManager();	45	private static FileProxyManager fileProxyManager = new FileProxyManager();
37		46
		47	private ProxiesRequests requests = new ProxiesRequests();
		48
38	/**	49	/**
39	* @return Returns the fileProxyManager.	50	* @return Returns the fileProxyManager.
40	*/	51	*/
Lines 42-47 Link Here
42	return fileProxyManager;	53	return fileProxyManager;
43	}	54	}
44		55
		56	public LogicalTestNavigatorProvider(TestNavigator testNavigator) {
		57	super(testNavigator);
		58	}
		59
45	public Object getParent(Object element) {	60	public Object getParent(Object element) {
46	Object parent = super.getParent(element);	61	Object parent = super.getParent(element);
47	if (parent instanceof FileProxyManager.IUnboundedParent) {	62	if (parent instanceof FileProxyManager.IUnboundedParent) {
Lines 63-96 Link Here
63	}	78	}
64		79
65	public Object[] getChildren(Object parentElement) {	80	public Object[] getChildren(Object parentElement) {
66	if(parentElement instanceof IProject && ((IProject)parentElement).isOpen()) {	81	if(parentElement instanceof IProject) {
67	//- for the given project we need to build all the type provider proxy node trees.	82	IProject project = (IProject)parentElement;
68	List providers = getTypeProviders((IProject)parentElement);	83	if (project.isAccessible()) {
69	//- append all test asset groups found in this project	84	Collection types = getTypes();
70	List groups = TestNavigator.getTestAssetGroupProxyManager().getTestAssetGroups((IProject)parentElement);	85	Collection extensions = getExtensions();
71	return mergeChildren(providers, groups);	86	ArrayList ret = new ArrayList(types.size() + extensions.size());
		87	LogicalProjectProxiesRequest request = requests.getRequest(project, types, extensions);
		88	for (Iterator it = types.iterator(); it.hasNext();) {
		89	String type = (String) it.next();
		90	IProxyNode proxy = request.getProxy(LogicalProjectProxiesRequest.TYPE_PROVIDER_PREFIX + type);
		91	if (proxy != null) {
		92	ret.add(proxy);
		93	}
		94	}
		95	for (Iterator it = extensions.iterator(); it.hasNext();) {
		96	String ext = (String) it.next();
		97	IProxyNode proxy = request.getProxy(LogicalProjectProxiesRequest.TEST_ASSET_EXTENSION_PREFIX + ext);
		98	if (proxy != null) {
		99	ret.add(proxy);
		100	}
		101	}
		102	if (request.isPending()) {
		103	ret.add(0, new PendingProxy(project));
		104	}
		105	return ret.toArray();
		106	}
		107	return new Object[0];
72	}	108	}
73	return super.getChildren(parentElement);	109	return super.getChildren(parentElement);
74	}	110	}
75		111
76	private List getTypeProviders(IProject project) {	112	private Collection getTypes() {
77	List typeProviders = new LinkedList();
78	//- for all defined test suite types, call the type provider factory
79	AssociationMappingRegistry registry = (AssociationMappingRegistry)TestUIExtension.getTestSuiteMappingRegistry();	113	AssociationMappingRegistry registry = (AssociationMappingRegistry)TestUIExtension.getTestSuiteMappingRegistry();
80	IAssociationMapping associationMapping = registry.getAssociationMapping(IAssociationConstants.EP_TYPE_DESCRIPTIONS);	114	IAssociationMapping associationMapping = registry.getAssociationMapping(IAssociationConstants.EP_TYPE_DESCRIPTIONS);
81	String[] types = associationMapping.getTypes();	115	String[] types = associationMapping.getTypes();
		116	List typeProviders = new ArrayList(types.length);
82	for (int i = 0; i < types.length; i++) {	117	for (int i = 0; i < types.length; i++) {
83	IAssociationDescriptor descriptor = associationMapping.getDefaultAssociationDescriptor(types[i]);	118	IAssociationDescriptor descriptor = associationMapping.getDefaultAssociationDescriptor(types[i]);
84	if (descriptor != null) {	119	if (descriptor != null) {
85	ITypeProviderProxyNode proxy = TestNavigator.getTypeProviderManager().getTypeProviderProxyNode(project, types[i]);	120	typeProviders.add(types[i]);
86	if(proxy != null) {
87	typeProviders.add(proxy);
88	}
89	}	121	}
90	}	122	}
91	return typeProviders;	123	return typeProviders;
92	}	124	}
93		125
		126	private Collection getExtensions() {
		127	return TestNavigator.getTestAssetGroupProxyManager().getExtensions();
		128	}
		129
94	private Object[] mergeChildren(List providers, List groups) {	130	private Object[] mergeChildren(List providers, List groups) {
95	Object[] children = new Object[providers.size()+groups.size()];	131	Object[] children = new Object[providers.size()+groups.size()];
96	int i = 0;	132	int i = 0;
Lines 102-107 Link Here
102	}	138	}
103	return children;	139	return children;
104	}	140	}
		141
		142	public IProxyNodeListener getProxyNodeListener() {
		143	return requests;
		144	}
		145
		146	public void dispose() {
		147	requests.dispose();
		148	super.dispose();
		149	}
		150
		151	class ProxiesRequests implements IProxiesRequestListener, IProxyNodeListener, IDisposable {
		152
		153	private Map projectToRequestMap = new HashMap();
		154
		155	public LogicalProjectProxiesRequest getRequest(IProject project, Collection types, Collection extensions) {
		156	LogicalProjectProxiesRequest req = (LogicalProjectProxiesRequest)projectToRequestMap.get(project);
		157	if (req == null) {
		158	ArrayList requests = new ArrayList(types.size() + extensions.size());
		159	for(Iterator it = types.iterator(); it.hasNext(); ) {
		160	requests.add(LogicalProjectProxiesRequest.TYPE_PROVIDER_PREFIX + (String)it.next());
		161	}
		162	for(Iterator it = extensions.iterator(); it.hasNext(); ) {
		163	requests.add(LogicalProjectProxiesRequest.TEST_ASSET_EXTENSION_PREFIX + (String)it.next());
		164	}
		165	req = new LogicalProjectProxiesRequest(requests, TestNavigator.getTypeProviderManager(), TestNavigator.getTestAssetGroupProxyManager(), project, testNavigator);
		166	req.setPriority(getJobPriority());
		167	testNavigator.getJobPool().scheduleJob(req);
		168	if (!req.wait(getResponseTime(), this, 2000)) {
		169	projectToRequestMap.put(project, req);
		170	}
		171	}
		172	return req;
		173	}
		174
		175	public void computationCompleted(ProxiesRequest request) {
		176	IProject project = ((LogicalProjectProxiesRequest)request).getProject();
		177	if (projectToRequestMap.containsKey(project)) {
		178	// A last refresh is necessary to remove the "Pending..." node.
		179	testNavigator.refresh(project);
		180	}
		181	}
		182
		183	public void proxiesComputed(ProxiesRequest request) {
		184	IProject project = ((LogicalProjectProxiesRequest)request).getProject();
		185	testNavigator.refresh(project);
		186	}
105		187
		188	public void proxyComputed(ProxiesRequest request, Object key) {
		189	}
		190
		191	public void nodeChanged(Object node) {
		192	if (node instanceof IProject) {
		193	LogicalProjectProxiesRequest req = (LogicalProjectProxiesRequest) projectToRequestMap.get(node);
		194	if (req != null) {
		195	// Then we need to cancel the current request. A new one will be spawned
		196	// when getChildren() is invoked on this project.
		197	if (req.cancel(1000)) {
		198	projectToRequestMap.remove(node);
		199	testNavigator.refresh(node);
		200	}
		201	}
		202	}
		203	}
		204
		205	public void computationCancelled(ProxiesRequest request) {
		206	IProject project = ((LogicalProjectProxiesRequest)request).getProject();
		207	projectToRequestMap.remove(project);
		208	testNavigator.refresh(project);
		209	}
		210
		211	public void dispose() {
		212	// Cancel all running requests. Note that a LogicalProjectProxiesRequest may take
		213	// considerable time before it can honor the cancel request. So in general the
		214	// request may be still running for a long time after this instance has been
		215	// disposed.
		216	// If the user switches from the logical view to the resource view, and then back
		217	// to the logical view, this provider is disposed, and then another instance gets
		218	// created. As a result, two requests for the same project may be running: the old
		219	// one, which has been cancelled but has not stopped yet, and the new one. This
		220	// will look as if two jobs are doing the same thing at the same time. However what
		221	// really happens is that the new job is blocked on a wait until the old request
		222	// completes, and then the new job automatically leverages the computation performed
		223	// by the old one, so there is no CPU waste. The only drawback is that the new job
		224	// occupies a slot in the Test navigator job pool.
		225	for (Iterator it = projectToRequestMap.values().iterator(); it.hasNext();) {
		226	ProxiesRequest request = (ProxiesRequest) it.next();
		227	request.dispose();
		228	it.remove();
		229	}
		230	}
		231
		232	}
		233
		234	private static class PendingProxy implements IProxyNode {
		235	public PendingProxy(Object parent) {
		236	this.parent = parent;
		237	}
		238	private Object parent;
		239	private static IProxyNode[] NO_CHILDREN = new IProxyNode[0];
		240	public IProxyNode[] getChildren() {
		241	return NO_CHILDREN;
		242	}
		243	public Image getImage() {
		244	return null;
		245	}
		246	public Object getParent() {
		247	return parent;
		248	}
		249	public String getText() {
		250	return TestNavigatorMessages.NODE_PENDING;
		251	}
252	public Object getAdapter(Class adapter) {
253	return null;
254	}
255	public String getIdentifier() {
256	return "~"; //$NON-NLS-1$
257	}
258	public IResource getUnderlyingResource() {
259	return null;
260	}
261	}
106		262
107	}	263	}

Lines 26-31 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/TestNavigatorMessages.java (+6 lines)
26		26
27	public static String TEST_NAVIGATOR_UNNAMED_ELEMENT;	27	public static String TEST_NAVIGATOR_UNNAMED_ELEMENT;
28	public static String PROXY_LOADING_ERROR;	28	public static String PROXY_LOADING_ERROR;
		29	public static String NODE_PENDING;
29	public static String OpenWithActionGroup_ActionLabel;	30	public static String OpenWithActionGroup_ActionLabel;
30	public static String FileFolderInContainerPaste_NameTwoArg;	31	public static String FileFolderInContainerPaste_NameTwoArg;
31	public static String FileFolderInContainerPaste_NameOneArg;	32	public static String FileFolderInContainerPaste_NameOneArg;
Lines 35-38 Link Here
35	public static String FileFolderInContainerPaste_MessageLabel;	36	public static String FileFolderInContainerPaste_MessageLabel;
36	public static String TestNavigatorActionGroup_ToggleAction_Text;	37	public static String TestNavigatorActionGroup_ToggleAction_Text;
37	public static String RenameAction_ActionName;	38	public static String RenameAction_ActionName;
		39	public static String PM_INDEXING_TYPE;
		40	public static String PM_INDEXING_ASSET_GROUP;
		41	public static String PM_EXPLORING_PROJECT;
		42	public static String PM_EXPLORING_FOLDER;
		43	public static String PM_INDEXING_FILE;
38	}	44	}




package org.eclipse.hyades.test.ui.navigator;

import org.eclipse.core.resources.IProject;
import org.eclipse.hyades.ui.util.IDisposable;

/** 
 * Type providers are responsible to collect and organize all elements of a given type
 * located in a project. The returned node is shown in the logical view of the test navigator. 
 * The returned proxy nodes lifecyle is under the type provider responsibility. If the type provider
 * implements the {@link IDisposable} interface, the {@link IDisposable#dispose()} will
 * be invoked when the provider is no longer necessary.
 * From a performance perspective, it is better for a type provider implementation to cache
 * its returned values, unless their computing is trivial.
 * Type providers also have the responsibility of providing updates of their content by
 * using the provided context's {@link IProxyNodeListener}.
 *  
 * @author jgout
 * @since 4.0

public interface ITypeProvider /*extends IDisposable*/ {
    
    /**
     * Initializes the type provider with a context.
     * @param context The context in which the type provider will be used. The context
     * provides various tools and information for the provider to interact with its
     * context.
     */
    public void init(ITypeProviderContext context);

	/**
	 * Returns a proxy node hierarchy based of the given type from elements located in the given project.
	 * The returned hierarchy will appear as a special type provider node directly under the project.
	 * The implementation should not assume anything about the thread it will run in. This method
	 * may be invoked from any thread, and concurrent calls to this method may happen. However
	 * there will never be two concurrent calls for the same project.
	 * @param project the owner of the returned hierarchy. 
	 * @param type the type of elements that type provider is interested in.
 	 * 
	 * @return a proxy node tree that represents all elements of the given type contained by the given project.
	 */
	public ITypeProviderProxyNode get(IProject project, String type);




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.util;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.hyades.ui.util.IDisposable;

public class FixedSizeJobPool implements IDisposable {

	private int maxJobs;
	private int runningJobs = 0;
	private List queue = Collections.synchronizedList(new LinkedList());
	private Object lock = new Object();
	private boolean disposed;
	
	public FixedSizeJobPool(int maxJobs) {
		this.maxJobs = maxJobs;
	}
	
	public void scheduleJob(Job job) {
		queue.add(job);
		synchronized(lock) {
			if (runningJobs < maxJobs) {
				doScheduleJob();
			}
		}
	}
	
	private void doScheduleJob() {
		if (disposed) return;
		if (!queue.isEmpty()) {
			Job job = (Job)queue.remove(0);
			job.addJobChangeListener(jobListener);
			runningJobs++;
			job.schedule();
		}
	}
	
	private IJobChangeListener jobListener = new JobChangeAdapter() {

		public void done(IJobChangeEvent event) {
			if (event.getResult() != null) {
				synchronized(lock) {
					runningJobs--;
					doScheduleJob();
				}
			}
		}
		
	};
	
	public void dispose() {
		disposed = true;
	}
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;

/**
 * A general purpose synchronizer that allows only one instance to access a given resource.
 * This synchronizer is mainly useful in multi-threaded contexts where one thread needs
 * exclusive access to a resource.
 * @author jcanches
 * @since 4.3
 */
public class SynchronizedAccess implements ISynchronizedAccess {

	private Collection locks = Collections.synchronizedList(new ArrayList(TestNavigator.BACKGROUND_JOB_POOL_SIZE + 1));
	
	/* (non-Javadoc)
	 * @see org.eclipse.hyades.test.ui.internal.navigator.proxy.async.ISynchronizedAccess#acquireLock(java.lang.Object)
	 */
	public boolean acquireLock(Object resource) {
		synchronized(locks) {
    		while (locks.contains(resource)) {
    			try {
					locks.wait();
				} catch (InterruptedException e) {
					return false;
				}
    		}
    		locks.add(resource);
    		return true;
    	}
	}
	/* (non-Javadoc)
	 * @see org.eclipse.hyades.test.ui.internal.navigator.proxy.async.ISynchronizedAccess#releaseLock(java.lang.Object)
	 */
	public void releaseLock(Object resource) {
		synchronized(locks) {
    		locks.remove(resource);
    		locks.notify();
    	}
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

/**
 * Listener of ProxiesRequest. This listener is notified of various events that occur in
 * the lifecycle of ProxiesRequest instances.
 * @author jcanches
 * @since 4.3
 */
public interface IProxiesRequestListener {

	/**
	 * Indicates that a proxy has been computed.
	 * @param request The request that was emitted and from which this event is sent.
	 * @param key The key whose proxy was computed.
	 */
	void proxyComputed(ProxiesRequest request, Object key);
	
	/**
	 * Indicates that at least one proxy has been computed since the last call to this method,
	 * or since {@link ProxiesRequest#wait(int, IProxyRequestListener, int)} has been called if
	 * this method has never been called before. This kind of notification is guaranted not to
	 * occur more often than the specified notification interval specified in the wait method,
	 * unless there are no more proxies to compute, in this case the notification occurs as soon
	 * as the last proxy is computed.
	 */
	void proxiesComputed(ProxiesRequest request);
	
	/**
	 * Indicates that the request has been completed.
	 * @param request The request that was emitted and which is now complete.
	 */
	void computationCompleted(ProxiesRequest request);
	
	/**
	 * Indicates that the request has been cancelled.
	 * @param request The request that was emitted and then cancelled.
	 */
	void computationCancelled(ProxiesRequest request);
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;

/**
 * Abstract job that belongs to a {@link TestNavigator} instance family. When disposed,
 * a test navigator cancels all jobs that belongs to its family.
 * @author jcanches
 * @since 4.3
 */
public abstract class TestNavigatorJob extends Job {

	private TestNavigator testNavigator;
	
	/**
	 * Constructs a job that belongs to the specified testNavigator.
	 * @param name Name of the job.
	 * @param testNavigator Instance of the test navigator that this job is a member of.
	 */
	protected TestNavigatorJob(String name, TestNavigator testNavigator) {
		super(name);
		this.testNavigator = testNavigator;
	}
	
	public boolean belongsTo(Object family) {
		if (testNavigator.equals(family)) return true;
		return super.belongsTo(family);
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

/**
 * A synchronized access allows only one instance to access a given resource.
 * The typical use is:
 * <pre>
 * try {
 *   if (access.acquireLock(resource)) {
 *     // Do something with the resource
 *   }
 * } finally {
 *   access.releaseLock(resource);
 * }
 * </pre>
 * Note that releaseLock must be called EVEN IF acquireLock failed.
 * @author jcanches
 * @since 4.3
 */
public interface ISynchronizedAccess {

	boolean acquireLock(Object resource);

	void releaseLock(Object resource);

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;

/**
 * An implementation of ISynchronizedAccess specially optimized for running in jobs.
 * The platform job manager is used to acquire and release locks, and a job waiting
 * for lock acquisition may let another non-blocked job meanwhile.
 * @author jcanches
 */
public class JobSynchronizedAccess implements ISynchronizedAccess {

	/**
	 * The list of rules that this instance currently owns. Must be protected against concurrent
	 * access because two jobs may acquire/release a lock for two different resources at the
	 * same time. Use an array list as small as the maximum number of background jobs the
	 * test navigator may launch, plus one (the UI thread), since there should be not more
	 * than this number of threads acquiring a lock at any time.
	 */
	private Collection rules = Collections.synchronizedList(new ArrayList(TestNavigator.BACKGROUND_JOB_POOL_SIZE + 1));
	
	/**
	 * A rule that ensures exclusive access to a given resource, when it has the same owner.
	 * In other words: a given owner can only have one job running within a ResourceRule
	 * block for a given resource.
	 * @author jcanches
	 */
	private static class ResourceRule implements ISchedulingRule {

		private JobSynchronizedAccess owner;
		private Object resource;

		public ResourceRule(JobSynchronizedAccess owner, Object resource) {
			this.owner = owner;
			this.resource = resource;
		}
		
		public boolean contains(ISchedulingRule rule) {
			if (rule == this) return true;
			// Any rule than can be contained in the workspace rule is also accepted
			return ResourcesPlugin.getWorkspace().getRoot().contains(rule);
		}

		public boolean isConflicting(ISchedulingRule rule) {
			if (rule instanceof ResourceRule) {
				ResourceRule oRule = (ResourceRule) rule;
				return this.owner == oRule.owner && this.resource.equals(oRule.resource);
			}
			return false;
		}
	}
	
	public boolean acquireLock(Object resource) {
		ResourceRule rule = new ResourceRule(this, resource);
		Platform.getJobManager().beginRule(rule, new NullProgressMonitor());
		rules.add(rule);
		return true;
	}

	private ResourceRule removeRule(Object resource) {
		for (Iterator it = rules.iterator(); it.hasNext();) {
			ResourceRule rule = (ResourceRule) it.next();
			if (rule.resource.equals(resource)) {
				it.remove();
				return rule;
			}
		}
		return null;
	}
	
	public void releaseLock(Object resource) {
		ResourceRule rule = removeRule(resource);
		if (rule != null) {
			Platform.getJobManager().endRule(rule);
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

import java.util.Collection;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigatorMessages;
import org.eclipse.hyades.test.ui.navigator.IFileProxyManager;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.graphics.Image;

/**
 * A ProxiesRequest that performs the long-running computation of proxy nodes for a
 * collection of files, using a FileProxyManager.
 * @author jcanches
 * @since 4.3
 */
public class FileProxiesRequest extends ProxiesRequest {

	private IFileProxyManager fileProxyManager;
	private IContainer parent;
	
	/**
	 * Constructs a new request.
	 * @param files The list of files for which proxy nodes must be computed.
	 * @param fileProxyManager The FileProxyManager used to compute the proxies.
	 * @param parent The common parent of all returned proxies.
	 */
	public FileProxiesRequest(Collection files, IFileProxyManager fileProxyManager, IContainer parent, TestNavigator testNavigator) {
		super(NLS.bind(TestNavigatorMessages.PM_EXPLORING_FOLDER, parent.getFullPath().toString()), files, testNavigator);
		this.fileProxyManager = fileProxyManager;
		this.parent = parent;
		//this.setRule(parent);
	}
	
	/**
	 * Returns the common parent of all computed proxies.
	 * @return the common parent of all computed proxies.
	 */
	public IContainer getParent() {
		return parent;
	}
	
	protected IProxyNode computeProxy(Object key) {
		return fileProxyManager.getProxy((IFile)key, parent);
	}
	
	protected IProxyNode getPlaceHolder(Object key) {
		return new TemporaryProxy((IFile)key, parent);
	}
	
	protected String getTaskName() {
		return NLS.bind(TestNavigatorMessages.PM_EXPLORING_FOLDER, parent.getFullPath().toString());
	}
	
	protected String getSubTaskName(Object key) {
		return NLS.bind(TestNavigatorMessages.PM_INDEXING_FILE, ((IFile)key).getName());
	}

	private static class TemporaryProxy implements IProxyNode {

		private IFile file;
		private Object parent;

		public TemporaryProxy(IFile file, Object parent) {
			this.file = file;
			this.parent = parent;
		}

		public IProxyNode[] getChildren() {
			return new IProxyNode[0];
		}

		public Image getImage() {
			// TODO Auto-generated method stub
			return null;
		}

		public Object getParent() {
			return parent;
		}

		public String getText() {
			return file.getName();
		}

		public Object getAdapter(Class adapter) {
			if (adapter.isAssignableFrom(IFile.class)) {
				return file;
			}
			return null;
		}

		public String getIdentifier() {
			return "#"; //$NON-NLS-1$
		}

		public IResource getUnderlyingResource() {
			return file;
		}
		
	}
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.hyades.test.ui.UiPlugin;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;
import org.eclipse.hyades.ui.util.IDisposable;

/**
 * A proxies request is a job that performs the computation, for a list
 * of keys, of a list of matching proxy nodes. Assuming that the proxies computation is
 * a long-running operation, the request can be queried for results at any time, even if
 * the result for the given key has not been computed yet. In this case, the request
 * returns a placeholder proxy.
 * The caller has the choice of waiting until the computation is completed, or not waiting 
 * and being notified when the computation progresses, or a mix of the two (i.e. wait for a
 * limited time, then switch to a notification method).
 * @author jcanches
 * @since 4.3
 */
public abstract class ProxiesRequest extends TestNavigatorJob implements IDisposable {

	private IProxiesRequestListener listener;
	private List requests;
	private Map results = Collections.synchronizedMap(new HashMap());
	private boolean cancelled;
	private long lastNotificationTime;
	private long notificationInterval;
	private boolean notificationNeeded;
	private State state = new State();
	private boolean issueCancelNotification = false;

	protected ProxiesRequest(String name, Collection keys, TestNavigator testNavigator) {
		super(name, testNavigator);
		this.requests = new ArrayList(keys);
		for (Iterator it = keys.iterator(); it.hasNext();) {
			Object key = it.next();
			IProxyNode proxy = getPlaceHolder(key);
			results.put(key, proxy);
		}
	}

	public IProxyNode getProxy(Object key) {
		return (IProxyNode)results.get(key);
	}

	/**
	 * Waits until this request is executed, or until the specified time-out is reached.
	 * @param timeOut A time, in milliseconds, that this method should not exceed.
	 * @param listener A listener that will be notified, if the request exceeds the time.
	 * @param notificationInterval The pace, in milliseconds, at which the method
	 * {@link IProxiesRequestListener#proxiesComputed(ProxiesRequest)} should be
	 * invoked. Only used if the request exceeds the time allocated.
	 * @return Whether the request could be completed in time or not. If not, the listener will
	 * be used to get asynchronous update of the state of the request.
	 * @throws OperationCanceledException If the method dispose() has already been called.
	 */
	public boolean wait(int timeOut, IProxiesRequestListener listener, int notificationInterval) throws OperationCanceledException {
		if (cancelled) throw new OperationCanceledException();
		synchronized(state) {
			if (state.getState() != State.COMPLETED) {
				try {
					state.wait(timeOut);
				} catch (InterruptedException e) {
					// OK
				}
			}
		}
		switch(state.getState()) {
		case State.RUNNING:
		case State.INITIALIZED: {
			this.notificationInterval = notificationInterval;
			this.listener = listener;
			this.lastNotificationTime = System.currentTimeMillis();
			return false;
		}
		case State.COMPLETED: {
			this.listener = listener;
			fireNotification(state);
			return true;
		}
		case State.CANCELLED: {
			throw new OperationCanceledException();
		}
		default: {
			throw new RuntimeException("Illegal internal state"); //$NON-NLS-1$
		}
		}
	}
	
	public boolean isPending() {
		int s = state.getState();
		return s == State.INITIALIZED || s == State.RUNNING;
	}

	/**
	 * Performs the computation. This method will trigger notification once a listener
	 * is registered. This method should be run in a separate thread.
	 */
	public IStatus run(IProgressMonitor monitor) {
		monitor.beginTask(getTaskName(), requests.size());
		synchronized(state) {
			state.set(State.RUNNING);
		}
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY + 2);
		try {
			for (Iterator it = requests.iterator(); !cancelled && it.hasNext();) {
				Object key = it.next();
				monitor.subTask(getSubTaskName(key));
				_computeProxy(key);
				if (monitor.isCanceled()) {
					cancelled = true;
				} else {
					monitor.worked(1);
				}
			}
		} finally {
			synchronized(state) {
				state.set(cancelled ? State.CANCELLED : State.COMPLETED);
				fireNotification(state);
				state.notifyAll();
			}
			monitor.done();
		}
		return new Status(IStatus.OK, UiPlugin.PLUGIN_ID, 0, "", null); //$NON-NLS-1$
	}
		
	private void _computeProxy(Object key) {
		IProxyNode proxy = computeProxy(key);
		results.put(key, proxy);
		fireNotification(key);
	}
	
	abstract protected IProxyNode getPlaceHolder(Object key);
	
	abstract protected IProxyNode computeProxy(Object key);
	
	abstract protected String getTaskName();
	
	abstract protected String getSubTaskName(Object key);
	
	private void fireNotification(Object key) {
		if (listener == null) return;
		try {
			if (key instanceof State) {
				if (state.getState() == State.CANCELLED) {
					if (issueCancelNotification) {
						listener.computationCancelled(this);
					}
				} else {
					if (notificationNeeded) {
						listener.proxiesComputed(this);
					}
					listener.computationCompleted(this);
				}
			} else if (!cancelled) {
				listener.proxyComputed(this, key);
				long now = System.currentTimeMillis();
				if (lastNotificationTime + notificationInterval < now) {
					listener.proxiesComputed(this);
					notificationNeeded = false;
					lastNotificationTime = now;
				} else {
					notificationNeeded = true;
				}
			}
		} catch (Throwable t) {
			UiPlugin.logError(t);
		}
	}
	
	public boolean cancel(int timeOut) {
		cancelled = true;
		// Wait a few seconds for the running thread to complete
		synchronized(state) {
			if (state.getState() == State.RUNNING) {
				try {
					state.wait(timeOut);
				} catch (InterruptedException e) {
					// OK
				}
				if (state.getState() == State.RUNNING) {
					issueCancelNotification = true;
					return false;
				}
			}
			return true;
		}
	}
	
	public void dispose() {
		cancel(1);
	}
	
	private static class State {
		
		public final static int INITIALIZED = 0;
		public final static int RUNNING = 1;
		public final static int CANCELLED = 2;
		public final static int COMPLETED = 3;
		
		private int state = INITIALIZED;
		
		public void set(int state) {
			this.state = state;
		}
		
		public int getState() {
			return state;
		}
		
	}
	
}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * $Id: $
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.hyades.test.ui.internal.navigator.proxy.async;

import java.util.Collection;

import org.eclipse.core.resources.IProject;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigatorMessages;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.ITestAssetGroupProxyNode;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.TestAssetGroupProxyManager;
import org.eclipse.hyades.test.ui.internal.navigator.proxy.TypeProviderManager;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;
import org.eclipse.hyades.test.ui.navigator.ITypeProviderProxyNode;
import org.eclipse.osgi.util.NLS;

/**
 * Request that computes the {@link ITypeProviderProxyNode}s and the {@link ITestAssetGroupProxyNode}
 * of a project. A request is a job that can be run as a background job, and that provides
 * additional events to the requester.
 * @author jcanches
 * @since 4.3
 */
public class LogicalProjectProxiesRequest extends ProxiesRequest {

	public static final String TYPE_PROVIDER_PREFIX = "#"; //$NON-NLS-1$
	public static final String TEST_ASSET_EXTENSION_PREFIX = "~"; //$NON-NLS-1$
	
	private IProject project;
	private TypeProviderManager typeProviderManager;
	private TestAssetGroupProxyManager testAssetGroupProxyManager;
	
	public LogicalProjectProxiesRequest(Collection requests, TypeProviderManager typeProviderManager, TestAssetGroupProxyManager testAssetGroupProxyManager, IProject project, TestNavigator testNavigator) {
		super(NLS.bind(TestNavigatorMessages.PM_EXPLORING_PROJECT, project.getName()), requests, testNavigator);
		this.project = project;
		this.typeProviderManager = typeProviderManager;
		this.testAssetGroupProxyManager = testAssetGroupProxyManager;
		//this.setRule(project);
	}
	
	public IProject getProject() {
		return project;
	}
	
	protected IProxyNode computeProxy(Object key) {
		String req = (String)key;
		if (req.startsWith(TYPE_PROVIDER_PREFIX)) {
			return typeProviderManager.getTypeProviderProxyNode(project, req.substring(1));
		} else if (req.startsWith(TEST_ASSET_EXTENSION_PREFIX)) {
			return testAssetGroupProxyManager.getTestAssetGroup(project, req.substring(1));
		}
		return null;
	}

	protected IProxyNode getPlaceHolder(Object key) {
		return null;
	}

	protected String getTaskName() {
		return NLS.bind(TestNavigatorMessages.PM_EXPLORING_PROJECT, project.getName());
	}
	
	protected String getSubTaskName(Object key) {
		String req = (String)key;
		if (req.startsWith(TYPE_PROVIDER_PREFIX)) {
			return NLS.bind(TestNavigatorMessages.PM_INDEXING_TYPE, req.substring(1));
		} else if (req.startsWith(TEST_ASSET_EXTENSION_PREFIX)) {
			return NLS.bind(TestNavigatorMessages.PM_INDEXING_ASSET_GROUP, req.substring(1));
		}
		return ""; //$NON-NLS-1$
	}

}





package org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator;

import java.util.Collections;
import java.util.List;

import org.eclipse.hyades.test.ui.TestUIExtension;
import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
import org.eclipse.hyades.test.ui.navigator.IProxyNode;

        setChildren(computeChildren());
	}
	
	protected List computeChildren() {
		RegularJUnitProvider provider = getProvider();
		if (provider.refresher == null) {
			return super.computeChildren();
		} else {
			provider.scheduleComputeChildren(this);
			return Collections.EMPTY_LIST;
		}
	}
	
	protected void computeActualChildren() {
		setChildren(RegularJUnitProviderProxyNode.super.computeChildren());
	}

	protected JavaElementProxyNode createChildProxy(IJavaElement childElement, IJavaElementDelta delta) {
		if (childElement instanceof IPackageFragmentRoot) {
			return RegularJUnitSourceFolderProxyNode.create((IPackageFragmentRoot)childElement, this, delta);




package org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.event.IJUnitTestSuiteFactoryEvent;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.event.IJUnitTestSuiteFactoryListener;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.event.JUnitTestSuiteCreatedEvent;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.event.JUnitTestSuiteDetachedEvent;
import org.eclipse.hyades.test.tools.core.internal.java.modelsync.event.JUnitTestSuiteFactoryEventManager;
import org.eclipse.hyades.test.tools.ui.ToolsUiPlugin;
import org.eclipse.hyades.test.tools.ui.java.internal.JavaMessages;
import org.eclipse.hyades.test.ui.navigator.IFileProxyManager;
import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;
import org.eclipse.hyades.test.ui.navigator.ITypeProvider;

    	disposed = true;
    	// disposed must be set to true before cancelling the current job, otherwise another
    	// job may be triggered while we cancel this one.
    	if (computeJob != null) computeJob.cancel();
    	if (refresher != null) {
	    	JUnitTestSuiteFactoryEventManager.getInstance().removeListener(this);
	        JavaCore.removeElementChangedListener(this);

		}
	}
	
	protected void proxyComputed(RegularJUnitProviderProxyNode proxy) {
		if (proxy.getChildren().length != 0) {
			IJavaProject project = proxy.getJavaProject();
			refresher.nodeChanged(project.getProject());
		}
	}
	
	protected ISchedulingRule mutualExlusionRule = new ISchedulingRule() {
		public boolean contains(ISchedulingRule rule) {
			if (rule == this) return true;
			if (rule instanceof IResource) return true;
			return false;
		}
		public boolean isConflicting(ISchedulingRule rule) {
			return rule == this;
		}
	};
	
	protected class ComputeJob extends Job {
		private Set proxies = new HashSet();
		public ComputeJob() {
			super(JavaMessages.REGULAR_JUNIT_EXPLORING_TESTS);
			setRule(mutualExlusionRule);
		}
		public void addProxy(RegularJUnitProviderProxyNode proxy) {
			proxies.add(proxy);
		}
		protected IStatus run(IProgressMonitor monitor) {
			monitor.beginTask(JavaMessages.REGULAR_JUNIT_EXPLORING_PROJECT, proxies.size());
			try {
				Iterator it = proxies.iterator();
				while (it.hasNext()) {
					RegularJUnitProviderProxyNode proxy = (RegularJUnitProviderProxyNode) it.next();
					try {
						monitor.subTask(proxy.getJavaElement().getElementName());
						proxy.computeActualChildren();
						proxyComputed(proxy);
					} catch (Throwable t) {
						ToolsUiPlugin.logError(t);
					} finally {
						it.remove();
						monitor.done();
					}
				}
				return new Status(IStatus.OK, ToolsUiPlugin.getID(), 0, "", null); //$NON-NLS-1$
			} finally {
				monitor.done();
			}
		}
	}
	
	private ComputeJob computeJob = null;
	
    /**
     * Returns an ComputeJob in NONE state (ie. ready to be scheduled).
     * @return
     */
    private synchronized ComputeJob getComputeJob() {
        if (computeJob != null) {
            if (computeJob.getState() != Job.RUNNING && computeJob.cancel()) {
                // The job is back to NONE state now
                return computeJob;
            } else {
                // Too late, our job is already running. Forget this one.
            	computeJob = null;
            }
        }
        if (computeJob == null) {
        	computeJob = new ComputeJob();
        }
        return computeJob;
    }

	/*package*/ void scheduleComputeChildren(RegularJUnitProviderProxyNode proxy) {
		Assert.isLegal(refresher != null, "Cannot delay children computation in static view mode"); //$NON-NLS-1$
		if (disposed) return;
		ComputeJob job = getComputeJob();
		job.addProxy(proxy);
		job.schedule(500);
	}

	/**
	 * Convenience method to get the proxy node associated to an arbitrary java element.
	 * @param element An opened java element.




 **********************************************************************/
package org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;


    protected IFileProxyManager fileProxyManager;
	protected IProxyNodeListener refresher;

	private Map projectToProxyMap = Collections.synchronizedMap(new HashMap());
	
	public JUnitTypeProvider() {
        FileProxyNodeCache.getInstance().addResourceListener(this);

				if (lowestChange != null) {
					refresher.nodeChanged(lowestChange);
				}
			} else if (affectedChildren[i].getKind() == IResourceDelta.ADDED) {
                //- if there is something added to this project, refresh it this can lead to type provider appearance
                refresher.nodeChanged(project);
            }

Return to bug 157089

Removed Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/proxy/TestNavigatorRefresher.java (-31 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: TestNavigatorRefresher.java,v 1.2 2005/04/26 15:55:53 jcanches Exp $
8	*
9	* Contributors:
10	* IBM Corporation - initial API and implementation
11	*******************************************************************************/
12	package org.eclipse.hyades.test.ui.internal.navigator.proxy;
13
14	import java.util.Iterator;
15
16	import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
17	import org.eclipse.hyades.test.ui.navigator.IProxyNodeListener;
18
19	/**
20	* @author jgout
21	*
22	*/
23	public class TestNavigatorRefresher implements IProxyNodeListener {
24
25	public void nodeChanged(Object node) {
26	for(Iterator it = TestNavigator.getAllInstancesIterator(); it.hasNext();) {
27	((TestNavigator)it.next()).nodeChanged(node);
28	}
29	}
30
31	}

Lines 23-28 Link Here

(-)src/org/eclipse/hyades/test/ui/internal/navigator/TestNavigator.java (-38 / +81 lines)
23	import org.eclipse.core.resources.ResourcesPlugin;	23	import org.eclipse.core.resources.ResourcesPlugin;
24	import org.eclipse.core.runtime.IAdaptable;	24	import org.eclipse.core.runtime.IAdaptable;
25	import org.eclipse.core.runtime.Path;	25	import org.eclipse.core.runtime.Path;
		26	import org.eclipse.core.runtime.Platform;
26	import org.eclipse.emf.common.util.URI;	27	import org.eclipse.emf.common.util.URI;
27	import org.eclipse.emf.ecore.EObject;	28	import org.eclipse.emf.ecore.EObject;
28	import org.eclipse.emf.ecore.resource.Resource;	29	import org.eclipse.emf.ecore.resource.Resource;
Lines 40-48 Link Here
40	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;	41	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyManager;
41	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyNodeCache;	42	import org.eclipse.hyades.test.ui.internal.navigator.proxy.FileProxyNodeCache;
42	import org.eclipse.hyades.test.ui.internal.navigator.proxy.TestAssetGroupProxyManager;	43	import org.eclipse.hyades.test.ui.internal.navigator.proxy.TestAssetGroupProxyManager;
43	import org.eclipse.hyades.test.ui.internal.navigator.proxy.TestNavigatorRefresher;
44	import org.eclipse.hyades.test.ui.internal.navigator.proxy.TypeProviderManager;	44	import org.eclipse.hyades.test.ui.internal.navigator.proxy.TypeProviderManager;
45	import org.eclipse.hyades.test.ui.internal.util.ContextIds;	45	import org.eclipse.hyades.test.ui.internal.util.ContextIds;
		46	import org.eclipse.hyades.test.ui.internal.util.FixedSizeJobPool;
46	import org.eclipse.hyades.test.ui.navigator.CMNNamedElementProxyNode;	47	import org.eclipse.hyades.test.ui.navigator.CMNNamedElementProxyNode;
47	import org.eclipse.hyades.test.ui.navigator.EObjectProxyNode;	48	import org.eclipse.hyades.test.ui.navigator.EObjectProxyNode;
48	import org.eclipse.hyades.test.ui.navigator.FileProxyNode;	49	import org.eclipse.hyades.test.ui.navigator.FileProxyNode;
Lines 110-115 Link Here
110		111
111	public static final int VIEW_ID_LOGICAL = 1;	112	public static final int VIEW_ID_LOGICAL = 1;
112		113
		114	/**
		115	* The size of the background job pool. This is the maximal number of background
		116	* jobs that can run at the same time.
		117	*/
		118	public static final int BACKGROUND_JOB_POOL_SIZE = 3;
		119
113	private int currentViewIndex;	120	private int currentViewIndex;
114		121
115	/**	122	/**
Lines 149-156 Link Here
149	/** actions to switch between both logical and resource views. */	156	/** actions to switch between both logical and resource views. */
150	private ToggleViewAction[] viewActions;	157	private ToggleViewAction[] viewActions;
151		158
152	/** Label and content provider for both logical and resource views. */	159	/** Current content and label provider. */
153	private TestNavigatorProvider[] providers;	160	private TestNavigatorProvider currentProvider;
154		161
155	// - constants are used in the IDialogSettings	162	// - constants are used in the IDialogSettings
156	protected final static String SET_SHOW_FOLDERS = "SHOW_FOLDERS"; //$NON-NLS-1$	163	protected final static String SET_SHOW_FOLDERS = "SHOW_FOLDERS"; //$NON-NLS-1$
Lines 164-170 Link Here
164	protected final static int CP_FOLDER = 0;	171	protected final static int CP_FOLDER = 0;
165		172
166	protected final static int CP_LOGICAL = 1;	173	protected final static int CP_LOGICAL = 1;
167		174
168	private List rootLogicalFolders;	175	private List rootLogicalFolders;
169		176
170	private boolean showingFolders = true;	177	private boolean showingFolders = true;
Lines 172-178 Link Here
172	private boolean showingEObjectChildren = true;	179	private boolean showingEObjectChildren = true;
173		180
174	private ResourceChangeUpdaterProvider resourceChangeUpdaterProvider;	181	private ResourceChangeUpdaterProvider resourceChangeUpdaterProvider;
175		182
		183	private FixedSizeJobPool jobPool;
		184
176	/**	185	/**
177	* Constructor for TestNavigator	186	* Constructor for TestNavigator
178	*/	187	*/
Lines 180-186 Link Here
180	super(ITestNavigator.ID);	189	super(ITestNavigator.ID);
181		190
182	viewActions = new ToggleViewAction[] { new ToggleViewAction(this, VIEW_ID_RESOURCE), new ToggleViewAction(this, VIEW_ID_LOGICAL) };	191	viewActions = new ToggleViewAction[] { new ToggleViewAction(this, VIEW_ID_RESOURCE), new ToggleViewAction(this, VIEW_ID_LOGICAL) };
183	providers = new TestNavigatorProvider[] { new ResourceTestNavigatorProvider(), new LogicalTestNavigatorProvider() };
184	}	192	}
185		193
186	/**	194	/**
Lines 263-275 Link Here
263	/**	271	/**
264	* @return Returns the typeProviderProxyManager.	272	* @return Returns the typeProviderProxyManager.
265	*/	273	*/
266	public static TypeProviderManager getTypeProviderManager() {	274	public synchronized static TypeProviderManager getTypeProviderManager() {
267	if (typeProviderManager == null) {	275	if (typeProviderManager == null) {
268	typeProviderManager = new TypeProviderManager(getTypeProviderContext());	276	typeProviderManager = new TypeProviderManager(getTypeProviderContext());
269	}	277	}
270	return typeProviderManager;	278	return typeProviderManager;
271	}	279	}
272		280
		281	private static class AllInstancesRefresher implements IProxyNodeListener {
		282	public void nodeChanged(Object node) {
		283	for(Iterator it = TestNavigator.getAllInstancesIterator(); it.hasNext();) {
		284	((TestNavigator)it.next()).nodeChanged(node);
		285	}
		286	}
		287	}
		288
273	/**	289	/**
274	* This class is responsible to give the correct context to the used ITypeProvider (DefaultTypeProvider).	290	* This class is responsible to give the correct context to the used ITypeProvider (DefaultTypeProvider).
275	* It stores the file proxy manager of the logical view to be used by the ITypeProvider,	291	* It stores the file proxy manager of the logical view to be used by the ITypeProvider,
Lines 283-289 Link Here
283	}	299	}
284	public IProxyNodeListener getProxyNodeListener() {	300	public IProxyNodeListener getProxyNodeListener() {
285	if (refresher == null) {	301	if (refresher == null) {
286	refresher = new TestNavigatorRefresher();	302	refresher = new AllInstancesRefresher();
287	}	303	}
288	return refresher;	304	return refresher;
289	}	305	}
Lines 299-307 Link Here
299	return typeProviderContext;	315	return typeProviderContext;
300	}	316	}
301		317
302	public static TestAssetGroupProxyManager getTestAssetGroupProxyManager() {	318	public synchronized static TestAssetGroupProxyManager getTestAssetGroupProxyManager() {
303	if (testAssetGroupProxyManager == null) {	319	if (testAssetGroupProxyManager == null) {
304	testAssetGroupProxyManager = new TestAssetGroupProxyManager();	320	testAssetGroupProxyManager = new TestAssetGroupProxyManager(getTypeProviderContext());
305	}	321	}
306	return testAssetGroupProxyManager;	322	return testAssetGroupProxyManager;
307	}	323	}
Lines 310-315 Link Here
310	* @see org.eclipse.ui.IWorkbenchPart#dispose()	326	* @see org.eclipse.ui.IWorkbenchPart#dispose()
311	*/	327	*/
312	public void dispose() {	328	public void dispose() {
		329	if (jobPool != null) {
		330	// Disposing the job pool cancels all pending jobs that have net been yet
		331	// scheduled.
		332	jobPool.dispose();
		333	}
		334	// Cancel all "TestNavigatorJob"s, i.e. jobs that belongs the "family" represented by
		335	// this instance. This cancels all jobs that have already been scheduled.
		336	Platform.getJobManager().cancel(this);
		337
313	if (rootLogicalFolders != null)	338	if (rootLogicalFolders != null)
314	rootLogicalFolders.clear();	339	rootLogicalFolders.clear();
315	removeTestNavigator(this);	340	removeTestNavigator(this);
Lines 319-331 Link Here
319	resourceChangeUpdaterProvider.dispose();	344	resourceChangeUpdaterProvider.dispose();
320	resourceChangeUpdaterProvider = null;	345	resourceChangeUpdaterProvider = null;
321		346
322	for (int i = 0; i < providers.length; i++) {
323	if(providers[i] != null){
324	providers[i].dispose();
325	providers[i] = null;
326	}
327	}
328
329	if(testAssetGroupProxyManager != null){	347	if(testAssetGroupProxyManager != null){
330	testAssetGroupProxyManager.dispose();	348	testAssetGroupProxyManager.dispose();
331	testAssetGroupProxyManager=null;	349	testAssetGroupProxyManager=null;
Lines 362-368 Link Here
362	addTestNavigator(this);	380	addTestNavigator(this);
363	}	381	}
364		382
365	/**	383	private void adjustCurrentProviderContext(boolean isLoading) {
		384	if (currentProvider != null) {
		385	if (isLoading) {
		386	currentProvider.setContext(TestNavigatorProvider.CONTEXT_LOADING);
		387	} else {
		388	currentProvider.setContext(TestNavigatorProvider.CONTEXT_INTERACTIVE);
		389	}
		390	}
		391	}
		392
		393	/**
366	* Returns the file associated to a given object that is located in this	394	* Returns the file associated to a given object that is located in this
367	* navigator.	395	* navigator.
368	*	396	*
Lines 496-502 Link Here
496	};	524	};
497	treeViewer.addFilter(viewerFilter);	525	treeViewer.addFilter(viewerFilter);
498		526
499	resourceChangeUpdaterProvider = new ResourceChangeUpdaterProvider.UIUpdaterProvider();	527	resourceChangeUpdaterProvider = new ResourceChangeUpdaterProvider.UIUpdaterProvider(false);
500	FileProxyNodeCache.getInstance().addResourceListener(resourceChangeUpdaterProvider);	528	FileProxyNodeCache.getInstance().addResourceListener(resourceChangeUpdaterProvider);
501	IResourceChangeUpdater resourceChangeUpdater = new TestResourceChangeUpdater(this);	529	IResourceChangeUpdater resourceChangeUpdater = new TestResourceChangeUpdater(this);
502	resourceChangeUpdaterProvider.setResourceChangeUpdater(resourceChangeUpdater);	530	resourceChangeUpdaterProvider.setResourceChangeUpdater(resourceChangeUpdater);
Lines 508-516 Link Here
508	* @param treeViewer	536	* @param treeViewer
509	*/	537	*/
510	private void updateTestNavigatorProvider(TreeViewer treeViewer) {	538	private void updateTestNavigatorProvider(TreeViewer treeViewer) {
511	treeViewer.setContentProvider(providers[currentViewIndex]);	539	if (currentViewIndex == VIEW_ID_RESOURCE) {
		540	currentProvider = new ResourceTestNavigatorProvider(this);
		541	} else {
		542	currentProvider = new LogicalTestNavigatorProvider(this);
		543	}
		544	adjustCurrentProviderContext(true);
		545	treeViewer.setContentProvider(currentProvider);
512	ILabelDecorator decorator = PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator();	546	ILabelDecorator decorator = PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator();
513	treeViewer.setLabelProvider(new TestDecoratingLabelProvider(providers[currentViewIndex], decorator, this));	547	ILabelProvider labelProvider = new TestDecoratingLabelProvider(currentProvider, decorator, this);
		548	treeViewer.setLabelProvider(labelProvider);
		549	adjustCurrentProviderContext(false);
514	}	550	}
515		551
516	/**	552	/**
Lines 524-544 Link Here
524	if (input instanceof IFileEditorInput) {	560	if (input instanceof IFileEditorInput) {
525	IFileEditorInput fileInput = (IFileEditorInput) input;	561	IFileEditorInput fileInput = (IFileEditorInput) input;
526	IFile file = fileInput.getFile();	562	IFile file = fileInput.getFile();
527		563	selectReveal(new StructuredSelection(file));
528	Resource resource = EMFUtil.getResource(null, file);	564	return true;
529	if ((resource != null) && (!resource.getContents().isEmpty())) {
530	IStructuredSelection structuredSelection = getStructuredSelection();
531	if (structuredSelection.size() == 1) {
532	Object currentSelection = structuredSelection.getFirstElement();
533	if (currentSelection instanceof EObject) {
534	if (((EObject) currentSelection).eResource() == resource)
535	return true;
536	}
537	}
538
539	selectReveal(new StructuredSelection(resource.getContents().get(0)));
540	return true;
541	}
542	}	565	}
543		566
544	return false;	567	return false;
Lines 962-971 Link Here
962	}	985	}
963	}	986	}
964		987
		988	/**
		989	* Invoked by test providers to notify that a node and its children should be refreshed.
		990	*/
965	public void nodeChanged(Object node) {	991	public void nodeChanged(Object node) {
966	Display.getDefault().asyncExec(new Refresher(node));	992	currentProvider.getProxyNodeListener().nodeChanged(node);
		993	refresh(node);
967	}	994	}
968		995
		996	/**
		997	* Internal method used by the provider to refresh a node and its sub-nodes. The difference
		998	* with nodeChanged(Object) is that this method does not notify the provider with the change.
		999	* @param node
		1000	*/
		1001	/package/void refresh(Object node) {
		1002	Display.getDefault().asyncExec(new Refresher(node));
		1003	}
		1004
969	/**	1005	/**
970	* @return	1006	* @return
971	*/	1007	*/
Lines 1008-1011 Link Here
1008	return "[Invalid Descriptor]"; //$NON-NLS-1$	1044	return "[Invalid Descriptor]"; //$NON-NLS-1$
1009	}	1045	}
1010	}	1046	}
		1047
		1048	public FixedSizeJobPool getJobPool() {
		1049	if (jobPool == null) {
		1050	jobPool = new FixedSizeJobPool(BACKGROUND_JOB_POOL_SIZE);
		1051	}
		1052	return jobPool;
		1053	}
1011	}	1054	}

Lines 12-23 Link Here

(-)src/org/eclipse/hyades/test/ui/navigator/ITypeProvider.java (-9 / +19 lines)
12	package org.eclipse.hyades.test.ui.navigator;	12	package org.eclipse.hyades.test.ui.navigator;
13		13
14	import org.eclipse.core.resources.IProject;	14	import org.eclipse.core.resources.IProject;
		15	import org.eclipse.hyades.ui.util.IDisposable;
15		16
16	/**	17	/**
17	* Type providers are responsible to collect and organize all elements of a given type	18	* Type providers are responsible to collect and organize all elements of a given type
18	* located in a project. The returned node is shown in the logical view of the test navigator.	19	* located in a project. The returned node is shown in the logical view of the test navigator.
19	* Implementors are responsible to manage the proxy nodes produced as they want	20	* The returned proxy nodes lifecyle is under the type provider responsibility. If the type provider
20	* (default implementation uses a cache to increase performance).	21	* implements the {@link IDisposable} interface, the {@link IDisposable#dispose()} will
		22	* be invoked when the provider is no longer necessary.
		23	* From a performance perspective, it is better for a type provider implementation to cache
		24	* its returned values, unless their computing is trivial.
		25	* Type providers also have the responsibility of providing updates of their content by
		26	* using the provided context's {@link IProxyNodeListener}.
21	*	27	*
22	* @author jgout	28	* @author jgout
23	* @since 4.0	29	* @since 4.0
Lines 25-41 Link Here
25	public interface ITypeProvider /extends IDisposable/ {	31	public interface ITypeProvider /extends IDisposable/ {
26		32
27	/**	33	/**
28	* Make some initialization for the type provider.	34	* Initializes the type provider with a context.
29	* @param context this parameter contains all inputs necessary to initialize the type provider.	35	* @param context The context in which the type provider will be used. The context
30	* For instance, a file proxy manager is set.	36	* provides various tools and information for the provider to interact with its
		37	* context.
31	*/	38	*/
32	public void init(ITypeProviderContext context);	39	public void init(ITypeProviderContext context);
33		40
34	/** Returns a proxy node hierarchy based of the given type from elements located in the given project.	41	/**
		42	* Returns a proxy node hierarchy based of the given type from elements located in the given project.
35	* The returned hierarchy will appear as a special type provider node directly under the project.	43	* The returned hierarchy will appear as a special type provider node directly under the project.
		44	* The implementation should not assume anything about the thread it will run in. This method
		45	* may be invoked from any thread, and concurrent calls to this method may happen. However
		46	* there will never be two concurrent calls for the same project.
36	* @param project the owner of the returned hierarchy.	47	* @param project the owner of the returned hierarchy.
37	* @param type the type of elements that type provider is interested in.	48	* @param type the type of elements that type provider is interested in.
38	*
39	* @return a proxy node tree that represents all elements of the given type contained by the given project.	49	* @return a proxy node tree that represents all elements of the given type contained by the given project.
40	*/	50	*/
41	public ITypeProviderProxyNode get(IProject project, String type);	51	public ITypeProviderProxyNode get(IProject project, String type);

Added Link Here

(-)src/org/eclipse/hyades/test/ui/internal/util/FixedSizeJobPool.java (+73 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id: $
8	*
9	* Contributors:
10	* IBM Corporation - initial API and implementation
11	*******************************************************************************/
12
13	package org.eclipse.hyades.test.ui.internal.util;
14
15	import java.util.Collections;
16	import java.util.LinkedList;
17	import java.util.List;
18
19	import org.eclipse.core.runtime.jobs.IJobChangeEvent;
20	import org.eclipse.core.runtime.jobs.IJobChangeListener;
21	import org.eclipse.core.runtime.jobs.Job;
22	import org.eclipse.core.runtime.jobs.JobChangeAdapter;
23	import org.eclipse.hyades.ui.util.IDisposable;
24
25	public class FixedSizeJobPool implements IDisposable {
26
27	private int maxJobs;
28	private int runningJobs = 0;
29	private List queue = Collections.synchronizedList(new LinkedList());
30	private Object lock = new Object();
31	private boolean disposed;
32
33	public FixedSizeJobPool(int maxJobs) {
34	this.maxJobs = maxJobs;
35	}
36
37	public void scheduleJob(Job job) {
38	queue.add(job);
39	synchronized(lock) {
40	if (runningJobs < maxJobs) {
41	doScheduleJob();
42	}
43	}
44	}
45
46	private void doScheduleJob() {
47	if (disposed) return;
48	if (!queue.isEmpty()) {
49	Job job = (Job)queue.remove(0);
50	job.addJobChangeListener(jobListener);
51	runningJobs++;
52	job.schedule();
53	}
54	}
55
56	private IJobChangeListener jobListener = new JobChangeAdapter() {
57
58	public void done(IJobChangeEvent event) {
59	if (event.getResult() != null) {
60	synchronized(lock) {
61	runningJobs--;
62	doScheduleJob();
63	}
64	}
65	}
66
67	};
68
69	public void dispose() {
70	disposed = true;
71	}
72
73	}

Lines 12-20 Link Here

(-)src/org/eclipse/hyades/test/tools/ui/java/internal/junit/navigator/RegularJUnitProviderProxyNode.java (-17 lines)
12		12
13	package org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator;	13	package org.eclipse.hyades.test.tools.ui.java.internal.junit.navigator;
14		14
15	import java.util.Collections;
16	import java.util.List;
17
18	import org.eclipse.hyades.test.ui.TestUIExtension;	15	import org.eclipse.hyades.test.ui.TestUIExtension;
19	import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;	16	import org.eclipse.hyades.test.ui.internal.navigator.TestNavigator;
20	import org.eclipse.hyades.test.ui.navigator.IProxyNode;	17	import org.eclipse.hyades.test.ui.navigator.IProxyNode;
Lines 59-78 Link Here
59	setChildren(computeChildren());	56	setChildren(computeChildren());
60	}	57	}
61		58
62	protected List computeChildren() {
63	RegularJUnitProvider provider = getProvider();
64	if (provider.refresher == null) {
65	return super.computeChildren();
66	} else {
67	provider.scheduleComputeChildren(this);
68	return Collections.EMPTY_LIST;
69	}
70	}
71
72	protected void computeActualChildren() {
73	setChildren(RegularJUnitProviderProxyNode.super.computeChildren());
74	}
75
76	protected JavaElementProxyNode createChildProxy(IJavaElement childElement, IJavaElementDelta delta) {	59	protected JavaElementProxyNode createChildProxy(IJavaElement childElement, IJavaElementDelta delta) {
77	if (childElement instanceof IPackageFragmentRoot) {	60	if (childElement instanceof IPackageFragmentRoot) {
78	return RegularJUnitSourceFolderProxyNode.create((IPackageFragmentRoot)childElement, this, delta);	61	return RegularJUnitSourceFolderProxyNode.create((IPackageFragmentRoot)childElement, this, delta);