Attachment 64656 Details for Bug 182930 – Other improvement

[patch] Other improvement

182930f.txt (text/plain), 24.87 KB, created by Jerome Lanneluc

on 2007-04-23 17:03:39 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Jerome Lanneluc

Created: 2007-04-23 17:03:39 EDT

Size: 24.87 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: model/org/eclipse/jdt/internal/core/JavaProject.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java,v
>retrieving revision 1.388
>diff -u -r1.388 JavaProject.java
>--- model/org/eclipse/jdt/internal/core/JavaProject.java	18 Apr 2007 14:30:40 -0000	1.388
>+++ model/org/eclipse/jdt/internal/core/JavaProject.java	23 Apr 2007 20:59:54 -0000
>@@ -66,6 +66,7 @@
> import org.eclipse.jdt.internal.compiler.util.ObjectVector;
> import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
> import org.eclipse.jdt.internal.core.JavaModelManager.PerProjectInfo;
>+import org.eclipse.jdt.internal.core.JavaProjectElementInfo.ProjectCache;
> import org.eclipse.jdt.internal.core.builder.JavaBuilder;
> import org.eclipse.jdt.internal.core.eval.EvaluationContextWrapper;
> import org.eclipse.jdt.internal.core.util.MementoTokenizer;
>@@ -1809,6 +1810,10 @@
> 	public IProject getProject() {
> 		return this.project;
> 	}
>+	
>+	public ProjectCache getProjectCache() throws JavaModelException {
>+		return ((JavaProjectElementInfo) getElementInfo()).getProjectCache(this);
>+	}
> 
> 	/**
> 	 * @see IJavaProject
>Index: model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java,v
>retrieving revision 1.46
>diff -u -r1.46 JavaProjectElementInfo.java
>--- model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java	23 Apr 2007 10:52:16 -0000	1.46
>+++ model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java	23 Apr 2007 20:59:54 -0000
>@@ -37,10 +37,10 @@
> 	static final IPackageFragmentRoot[] NO_ROOTS = new IPackageFragmentRoot[0];
> 
> 	static class ProjectCache {
>-		ProjectCache(IPackageFragmentRoot[] allPkgFragmentRootsCache, HashtableOfArrayToObject allPkgFragmentsCache, Map rootToResolvedEntries) {
>+		ProjectCache(IPackageFragmentRoot[] allPkgFragmentRootsCache, Map rootToResolvedEntries, Map pkgFragmentsCaches) {
> 			this.allPkgFragmentRootsCache = allPkgFragmentRootsCache;
>-			this.allPkgFragmentsCache = allPkgFragmentsCache;
> 			this.rootToResolvedEntries = rootToResolvedEntries;
>+			this.pkgFragmentsCaches = pkgFragmentsCaches;
> 		}
> 		
> 		/*
>@@ -50,9 +50,16 @@
> 		
> 		/*
> 		 * A cache of all package fragments in this project.
>-		 * (a map from String[] (the package name) to IPackageFragmentRoot[] (the package fragment roots that contain a package fragment with this name)
>+		 * (an array of a map from String[] (the package name) to IPackageFragmentRoot[] (the package fragment roots that contain a package fragment with this name))
> 		 */
>-		public HashtableOfArrayToObject allPkgFragmentsCache;
>+		public HashtableOfArrayToObject[] allPkgFragmentsCaches;
>+		
>+		/*
>+		 * A cache of package fragments for each package fragment root of this project
>+		 * (a map from IPackageFragmentRoot to
>+		 *  a map from String[] (the package name) to IPackageFragmentRoot[] (the package fragment roots that contain a package fragment with this name))
>+		 */
>+		public Map pkgFragmentsCaches;
> 		
> 		public Map rootToResolvedEntries;		
> 	}
>@@ -202,47 +209,21 @@
> 				reverseMap.clear();
> 			}
> 			
>-			HashMap otherRoots = JavaModelManager.getJavaModelManager().deltaState.otherRoots;
>-			HashtableOfArrayToObject fragmentsCache = new HashtableOfArrayToObject();
>-			for (int i = 0, length = roots.length; i < length; i++) {
>+			HashMap rootInfos = JavaModelManager.getJavaModelManager().deltaState.roots;
>+			HashMap pkgFragmentsCaches = new HashMap();
>+			int length = roots.length;
>+			for (int i = 0; i < length; i++) {
> 				IPackageFragmentRoot root = roots[i];
>-				IJavaElement[] frags = null;
>-				try {
>-					if (root.isArchive() 
>-							&& !root.isOpen() 
>-							&& otherRoots.get(((JarPackageFragmentRoot) root).jarPath) == null/*only if jar belongs to 1 project (https://bugs.eclipse.org/bugs/show_bug.cgi?id=161175)*/) {
>-						JarPackageFragmentRootInfo info = new JarPackageFragmentRootInfo();
>-						((JarPackageFragmentRoot) root).computeChildren(info, new HashMap());
>-						frags = info.children;
>-					} else 
>-						frags = root.getChildren();
>-				} catch (JavaModelException e) {
>-					// root doesn't exist: ignore
>-					continue;
>-				}
>-				for (int j = 0, length2 = frags.length; j < length2; j++) {
>-					PackageFragment fragment= (PackageFragment) frags[j];
>-					String[] pkgName = fragment.names;
>-					Object existing = fragmentsCache.get(pkgName);
>-					if (existing == null || existing == NO_ROOTS) {
>-						fragmentsCache.put(pkgName, root);
>-						// ensure super packages (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
>-						// are also in the map
>-						addSuperPackageNames(pkgName, fragmentsCache);
>-					} else {
>-						if (existing instanceof PackageFragmentRoot) {
>-							fragmentsCache.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
>-						} else {
>-							IPackageFragmentRoot[] entry= (IPackageFragmentRoot[]) existing;
>-							IPackageFragmentRoot[] copy= new IPackageFragmentRoot[entry.length + 1];
>-							System.arraycopy(entry, 0, copy, 0, entry.length);
>-							copy[entry.length]= root;
>-							fragmentsCache.put(pkgName, copy);
>-						}
>-					}
>+				DeltaProcessor.RootInfo rootInfo = (DeltaProcessor.RootInfo) rootInfos.get(root.getPath());
>+				if (rootInfo == null || rootInfo.project.equals(project)) {
>+					// compute fragment cache
>+					HashtableOfArrayToObject fragmentsCache = new HashtableOfArrayToObject();
>+					initializePackageNames(root, fragmentsCache);
>+					pkgFragmentsCaches.put(root, fragmentsCache);
> 				}
> 			}
>-			cache = new ProjectCache(roots, fragmentsCache, reverseMap);
>+			
>+			cache = new ProjectCache(roots, reverseMap, pkgFragmentsCaches);
> 			this.projectCache = cache;
> 		}
> 		return cache;
>@@ -258,6 +239,42 @@
> 		}
> 		return this.nonJavaResources;
> 	}
>+	
>+	private void initializePackageNames(IPackageFragmentRoot root, HashtableOfArrayToObject fragmentsCache) {
>+		IJavaElement[] frags = null;
>+		try {
>+			if (!root.isOpen()) {
>+				PackageFragmentRootInfo info = root.isArchive() ? new JarPackageFragmentRootInfo() : new PackageFragmentRootInfo();
>+				((PackageFragmentRoot) root).computeChildren(info, new HashMap());
>+				frags = info.children;
>+			} else 
>+				frags = root.getChildren();
>+		} catch (JavaModelException e) {
>+			// root doesn't exist: ignore
>+			return;
>+		}
>+		for (int j = 0, length2 = frags.length; j < length2; j++) {
>+			PackageFragment fragment= (PackageFragment) frags[j];
>+			String[] pkgName = fragment.names;
>+			Object existing = fragmentsCache.get(pkgName);
>+			if (existing == null || existing == NO_ROOTS) {
>+				fragmentsCache.put(pkgName, root);
>+				// ensure super packages (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
>+				// are also in the map
>+				addSuperPackageNames(pkgName, fragmentsCache);
>+			} else {
>+				if (existing instanceof PackageFragmentRoot) {
>+					fragmentsCache.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
>+				} else {
>+					IPackageFragmentRoot[] entry= (IPackageFragmentRoot[]) existing;
>+					IPackageFragmentRoot[] copy= new IPackageFragmentRoot[entry.length + 1];
>+					System.arraycopy(entry, 0, copy, 0, entry.length);
>+					copy[entry.length]= root;
>+					fragmentsCache.put(pkgName, copy);
>+				}
>+			}
>+		}
>+	}
> 
> 	/*
> 	 * Returns whether the given path is a classpath entry or an output location.
>@@ -284,7 +301,35 @@
> 	 */
> 	NameLookup newNameLookup(JavaProject project, ICompilationUnit[] workingCopies) {
> 		ProjectCache cache = getProjectCache(project);
>-		return new NameLookup(cache.allPkgFragmentRootsCache, cache.allPkgFragmentsCache, workingCopies, cache.rootToResolvedEntries);
>+		HashtableOfArrayToObject[] allPkgFragmentsCaches = cache.allPkgFragmentsCaches;
>+		if (allPkgFragmentsCaches == null) {
>+			HashMap rootInfos = JavaModelManager.getJavaModelManager().deltaState.roots;
>+			IPackageFragmentRoot[] roots = cache.allPkgFragmentRootsCache;
>+			int length = roots.length;
>+			allPkgFragmentsCaches = new HashtableOfArrayToObject[length];
>+			for (int i = 0; i < length; i++) {
>+				IPackageFragmentRoot root = roots[i];
>+				DeltaProcessor.RootInfo rootInfo = (DeltaProcessor.RootInfo) rootInfos.get(root.getPath());
>+				JavaProject rootProject = rootInfo == null ? project : rootInfo.project;
>+				HashtableOfArrayToObject fragmentsCache;
>+				if (rootProject.equals(project)) {
>+					fragmentsCache = (HashtableOfArrayToObject) cache.pkgFragmentsCaches.get(root);
>+				} else {
>+					// retrieve fragment cache from root project
>+					ProjectCache rootProjectCache;
>+					try {
>+						rootProjectCache = rootProject.getProjectCache();
>+					} catch (JavaModelException e) {
>+						// project doesn't exit
>+						continue;
>+					}
>+					fragmentsCache = (HashtableOfArrayToObject) rootProjectCache.pkgFragmentsCaches.get(root);
>+				}
>+				allPkgFragmentsCaches[i] = fragmentsCache;
>+			}
>+			cache.allPkgFragmentsCaches = allPkgFragmentsCaches;
>+		}
>+		return new NameLookup(cache.allPkgFragmentRootsCache, cache.allPkgFragmentsCaches, workingCopies, cache.rootToResolvedEntries);
> 	}
> 	
> 	/*
>Index: model/org/eclipse/jdt/internal/core/NameLookup.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/NameLookup.java,v
>retrieving revision 1.113
>diff -u -r1.113 NameLookup.java
>--- model/org/eclipse/jdt/internal/core/NameLookup.java	23 Apr 2007 10:52:16 -0000	1.113
>+++ model/org/eclipse/jdt/internal/core/NameLookup.java	23 Apr 2007 20:59:55 -0000
>@@ -123,7 +123,9 @@
> 	 * Note if the list is of size 1, then the IPackageFragmentRoot object
> 	 * replaces the array.
> 	 */
>-	protected HashtableOfArrayToObject packageFragments;
>+	protected HashtableOfArrayToObject[] packageFragmentsCaches;
>+	
>+	protected HashtableOfArrayToObject workingCopyFragmentsCache;
> 	
> 	/**
> 	 * Reverse map from root path to corresponding resolved CP entry
>@@ -142,29 +144,24 @@
> 
> 	public NameLookup(
> 			IPackageFragmentRoot[] packageFragmentRoots, 
>-			HashtableOfArrayToObject packageFragments, 
>+			HashtableOfArrayToObject[] packageFragmentsCaches, 
> 			ICompilationUnit[] workingCopies, 
> 			Map rootToResolvedEntries) {
> 		long start = -1;
> 		if (VERBOSE) {
> 			Util.verbose(" BUILDING NameLoopkup");  //$NON-NLS-1$
> 			Util.verbose(" -> pkg roots size: " + (packageFragmentRoots == null ? 0 : packageFragmentRoots.length));  //$NON-NLS-1$
>-			Util.verbose(" -> pkgs size: " + (packageFragments == null ? 0 : packageFragments.size()));  //$NON-NLS-1$
>+			//Util.verbose(" -> pkgs size: " + (packageFragments == null ? 0 : packageFragments.size()));  //$NON-NLS-1$
> 			Util.verbose(" -> working copy size: " + (workingCopies == null ? 0 : workingCopies.length));  //$NON-NLS-1$
> 			start = System.currentTimeMillis();
> 		}
> 		this.packageFragmentRoots = packageFragmentRoots;
>-		if (workingCopies == null) {
>-			this.packageFragments = packageFragments;
>-		} else {
>-			// clone tables as we're adding packages from working copies
>-			try {
>-				this.packageFragments = (HashtableOfArrayToObject) packageFragments.clone();
>-			} catch (CloneNotSupportedException e1) {
>-				// ignore (implementation of HashtableOfArrayToObject supports cloning)
>-			}
>+		this.packageFragmentsCaches = packageFragmentsCaches;
>+		this.workingCopyFragmentsCache = new HashtableOfArrayToObject();
>+		if (workingCopies != null) {
>+			// add packages from working copies first
> 			this.typesInWorkingCopies = new HashMap();
>-			for (int i = 0, length = workingCopies.length; i < length; i++) {
>+			for (int i = 0, length2 = workingCopies.length; i < length2; i++) {
> 				ICompilationUnit workingCopy = workingCopies[i];
> 				PackageFragment pkg = (PackageFragment) workingCopy.getParent();
> 				HashMap typeMap = (HashMap) this.typesInWorkingCopies.get(pkg);
>@@ -203,16 +200,16 @@
> 				// add root of package fragment to cache
> 				IPackageFragmentRoot root = (IPackageFragmentRoot) pkg.getParent();
> 				String[] pkgName = pkg.names;
>-				Object existing = this.packageFragments.get(pkgName);
>+				Object existing = this.workingCopyFragmentsCache.get(pkgName);
> 				if (existing == null || existing == JavaProjectElementInfo.NO_ROOTS) {
>-					this.packageFragments.put(pkgName, root);
>+					workingCopyFragmentsCache.put(pkgName, root);
> 					// ensure super packages (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
> 					// are also in the map
>-					JavaProjectElementInfo.addSuperPackageNames(pkgName, this.packageFragments);
>+					JavaProjectElementInfo.addSuperPackageNames(pkgName, this.workingCopyFragmentsCache);
> 				} else {
> 					if (existing instanceof PackageFragmentRoot) {
> 						if (!existing.equals(root))
>-							this.packageFragments.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
>+							this.workingCopyFragmentsCache.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
> 					} else {
> 						IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) existing;
> 						int rootLength = roots.length;
>@@ -226,7 +223,7 @@
> 						if (containsRoot) {
> 							System.arraycopy(roots, 0, roots = new IPackageFragmentRoot[rootLength+1], 0, rootLength);
> 							roots[rootLength] = root;
>-							this.packageFragments.put(pkgName, roots);
>+							this.workingCopyFragmentsCache.put(pkgName, roots);
> 						}
> 					}
> 				}
>@@ -325,18 +322,26 @@
> 		if (index != -1) {
> 			cuName= cuName.substring(0, index);
> 		}
>-		Object value = this.packageFragments.get(pkgName);
>-		if (value != null) {
>-			if (value instanceof PackageFragmentRoot) {
>-				return findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) value);
>-			} else {
>-				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
>-				for (int i= 0; i < roots.length; i++) {
>-					PackageFragmentRoot root= (PackageFragmentRoot) roots[i];
>-					ICompilationUnit cu = findCompilationUnit(pkgName, cuName, root);
>-					if (cu != null)
>-						return cu;
>-				}
>+		// lookup working copies package fragments
>+		Object value = this.workingCopyFragmentsCache.get(pkgName);
>+		if (value == null)
>+			return null;
>+		if (value instanceof PackageFragmentRoot) {
>+			return findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) value);
>+		} else {
>+			IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
>+			for (int i = 0, length = roots.length; i < length; i++) {
>+				ICompilationUnit cu = findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) roots[i]);
>+				if (cu != null)
>+					return cu;
>+			}
>+		}
>+		// lookup other package fragments
>+		for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
>+			if (this.packageFragmentsCaches[i].containsKey(pkgName)) {
>+				ICompilationUnit cu = findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) this.packageFragmentRoots[i]);
>+				if (cu != null)
>+					return cu;
> 			}
> 		}
> 		return null;
>@@ -421,21 +426,10 @@
> 					try {
> 						IClasspathEntry entry = project.getClasspathEntryFor(path);
> 						if (entry != null) {
>-							IPackageFragmentRoot root =
>-								project.getPackageFragmentRoot(project.getResource());
>-							Object defaultPkgRoot = this.packageFragments.get(CharOperation.NO_STRINGS);
>-							if (defaultPkgRoot == null) {
>-								return null;
>-							}
>-							if (defaultPkgRoot instanceof PackageFragmentRoot && defaultPkgRoot.equals(root))
>-								return  ((PackageFragmentRoot) root).getPackageFragment(CharOperation.NO_STRINGS);
>-							else {
>-								IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) defaultPkgRoot;
>-								for (int i = 0; i < roots.length; i++) {
>-									if (roots[i].equals(root)) {
>-										return  ((PackageFragmentRoot) root).getPackageFragment(CharOperation.NO_STRINGS);
>-									}
>-								}
>+							IPackageFragmentRoot root = project.getPackageFragmentRoot(project.getResource());
>+							for (int i = 0, length = this.packageFragmentRoots.length; i < length; i++) {
>+								if (root.equals(this.packageFragmentRoots[i]))
>+									return ((PackageFragmentRoot) root).getPackageFragment(CharOperation.NO_STRINGS);
> 							}
> 						}
> 					} catch (JavaModelException e) {
>@@ -460,15 +454,17 @@
> 	 *	only exact name matches qualify when <code>false</code>
> 	 */
> 	public IPackageFragment[] findPackageFragments(String name, boolean partialMatch) {
>+		IPackageFragment[] oneFragment = null;
>+		ArrayList pkgs = null;
>+		HashSet knownPkgs = null;
> 		if (partialMatch) {
> 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
>-			IPackageFragment[] oneFragment = null;
>-			ArrayList pkgs = null;
>-			Object[][] keys = this.packageFragments.keyTable;
>+			// lookup working copies package fragments
>+			Object[][] keys = this.workingCopyFragmentsCache.keyTable;
> 			for (int i = 0, length = keys.length; i < length; i++) {
> 				String[] pkgName = (String[]) keys[i];
> 				if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
>-					Object value = this.packageFragments.valueTable[i];
>+					Object value = this.workingCopyFragmentsCache.valueTable[i];
> 					if (value instanceof PackageFragmentRoot) {
> 						IPackageFragment pkg = ((PackageFragmentRoot) value).getPackageFragment(pkgName);
> 						if (oneFragment == null) {
>@@ -477,8 +473,11 @@
> 							if (pkgs == null) {
> 								pkgs = new ArrayList();
> 								pkgs.add(oneFragment[0]);
>+								knownPkgs = new HashSet();
>+								knownPkgs.add(oneFragment[0]);
> 							}
>-							pkgs.add(pkg);
>+							if (!knownPkgs.contains(pkg))
>+								pkgs.add(pkg);
> 						}
> 					} else {
> 						IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
>@@ -491,13 +490,40 @@
> 								if (pkgs == null) {
> 									pkgs = new ArrayList();
> 									pkgs.add(oneFragment[0]);
>+									knownPkgs = new HashSet();
>+									knownPkgs.add(oneFragment[0]);
> 								}
>-								pkgs.add(pkg);
>+								if (!knownPkgs.contains(pkg))
>+									pkgs.add(pkg);
> 							}
> 						}
> 					}
> 				}
> 			}
>+			// lookup other package fragments
>+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
>+				HashtableOfArrayToObject packageFragmentsCache = this.packageFragmentsCaches[i];
>+				PackageFragmentRoot root = (PackageFragmentRoot) this.packageFragmentRoots[i];
>+				keys = packageFragmentsCache.keyTable;
>+				for (int j = 0, length2 = keys.length; j < length2; j++) {
>+					String[] pkgName = (String[]) keys[j];
>+					if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
>+						IPackageFragment pkg = root.getPackageFragment(pkgName);
>+						if (oneFragment == null) {
>+							oneFragment = new IPackageFragment[] {pkg};
>+						} else {
>+							if (pkgs == null) {
>+								pkgs = new ArrayList();
>+								pkgs.add(oneFragment[0]);
>+								knownPkgs = new HashSet();
>+								knownPkgs.add(oneFragment[0]);
>+							}
>+							if (!knownPkgs.contains(pkg))
>+								pkgs.add(pkg);
>+						}
>+					}
>+				}
>+			}
> 			if (pkgs == null) return oneFragment;
> 			int resultLength = pkgs.size();
> 			IPackageFragment[] result = new IPackageFragment[resultLength];
>@@ -505,19 +531,45 @@
> 			return result;
> 		} else {
> 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
>-			Object value = this.packageFragments.get(splittedName);
>-			if (value == null)
>-				return null;
>-			if (value instanceof PackageFragmentRoot) {
>-				return new IPackageFragment[] {((PackageFragmentRoot) value).getPackageFragment(splittedName)};
>-			} else {
>-				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
>-				IPackageFragment[] result = new IPackageFragment[roots.length];
>-				for (int i= 0; i < roots.length; i++) {
>-					result[i] = ((PackageFragmentRoot) roots[i]).getPackageFragment(splittedName);
>+			// lookup working copies package fragments
>+			Object workingCopyRoot = this.workingCopyFragmentsCache.get(splittedName);
>+			if (workingCopyRoot != null) {
>+				if (workingCopyRoot instanceof PackageFragmentRoot) {
>+					oneFragment = new IPackageFragment[] {((PackageFragmentRoot) workingCopyRoot).getPackageFragment(splittedName)};
>+				} else {
>+					pkgs = new ArrayList();
>+					knownPkgs = new HashSet();
>+					IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) workingCopyRoot;
>+					for (int i= 0; i < roots.length; i++) {
>+						IPackageFragment pkg = ((PackageFragmentRoot) roots[i]).getPackageFragment(splittedName);
>+						pkgs.add(pkg);
>+						knownPkgs.add(pkg);
>+					}
>+				}
>+			}
>+			// lookup other package fragments
>+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
>+				if (this.packageFragmentsCaches[i].containsKey(splittedName)) {
>+					IPackageFragment pkg = ((PackageFragmentRoot) this.packageFragmentRoots[i]).getPackageFragment(splittedName);
>+					if (oneFragment == null) {
>+						oneFragment = new IPackageFragment[] {pkg};
>+					} else {
>+						if (pkgs == null) {
>+							pkgs = new ArrayList();
>+							pkgs.add(oneFragment[0]);
>+							knownPkgs = new HashSet();
>+							knownPkgs.add(oneFragment[0]);
>+						}
>+						if (!knownPkgs.contains(pkg))
>+							pkgs.add(pkg);
>+					}
> 				}
>-				return result;
> 			}
>+			if (pkgs == null) return oneFragment;
>+			int resultLength = pkgs.size();
>+			IPackageFragment[] result = new IPackageFragment[resultLength];
>+			pkgs.toArray(result);
>+			return result;
> 		}
> 	}
> 
>@@ -769,7 +821,13 @@
> 	}
> 	
> 	public boolean isPackage(String[] pkgName) {
>-		return this.packageFragments.get(pkgName) != null;
>+		if (this.workingCopyFragmentsCache.containsKey(pkgName))
>+			return true;
>+		for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
>+			if (this.packageFragmentsCaches[i].containsKey(pkgName))
>+				return true;
>+		}
>+		return false;
> 	}
> 
> 	/**
>@@ -826,13 +884,14 @@
> 		}
> */		if (partialMatch) {
> 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
>-			Object[][] keys = this.packageFragments.keyTable;
>+			// lookup working copies package fragments
>+			Object[][] keys = this.workingCopyFragmentsCache.keyTable;
> 			for (int i = 0, length = keys.length; i < length; i++) {
> 				if (requestor.isCanceled())
> 					return;
> 				String[] pkgName = (String[]) keys[i];
> 				if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
>-					Object value = this.packageFragments.valueTable[i];
>+					Object value = this.workingCopyFragmentsCache.valueTable[i];
> 					if (value instanceof PackageFragmentRoot) {
> 						PackageFragmentRoot root = (PackageFragmentRoot) value;
> 						requestor.acceptPackageFragment(root.getPackageFragment(pkgName));				
>@@ -847,13 +906,28 @@
> 					}
> 				}
> 			}
>+			// lookup other package fragments
>+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
>+				HashtableOfArrayToObject packageFragmentCache = this.packageFragmentsCaches[i];
>+				PackageFragmentRoot root = (PackageFragmentRoot) this.packageFragmentRoots[i];
>+				keys = packageFragmentCache.keyTable;
>+				for (int j = 0, length2 = keys.length; j < length2; j++) {
>+					if (requestor.isCanceled())
>+						return;
>+					String[] pkgName = (String[]) keys[j];
>+					if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
>+						requestor.acceptPackageFragment(root.getPackageFragment(pkgName));				
>+					}
>+				}
>+			}
> 		} else {
> 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
>-			Object value = this.packageFragments.get(splittedName);
>-			if (value instanceof PackageFragmentRoot) {
>-				requestor.acceptPackageFragment(((PackageFragmentRoot) value).getPackageFragment(splittedName));
>+			// lookup working copies package fragments
>+			Object workingCopyRoot = this.workingCopyFragmentsCache.get(splittedName);
>+			if (workingCopyRoot instanceof PackageFragmentRoot) {
>+				requestor.acceptPackageFragment(((PackageFragmentRoot) workingCopyRoot).getPackageFragment(splittedName));
> 			} else {
>-				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
>+				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) workingCopyRoot;
> 				if (roots != null) {
> 					for (int i = 0, length = roots.length; i < length; i++) {
> 						if (requestor.isCanceled())
>@@ -862,6 +936,14 @@
> 						requestor.acceptPackageFragment(root.getPackageFragment(splittedName));
> 					}
> 				}
>+			}	
>+			// lookup other package fragments
>+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
>+				if (requestor.isCanceled())
>+					return;
>+				if (this.packageFragmentsCaches[i].containsKey(splittedName)) {
>+					requestor.acceptPackageFragment(((PackageFragmentRoot) this.packageFragmentRoots[i]).getPackageFragment(splittedName));
>+				}
> 			}
> 		}
> 	}

Actions: View | Diff

Attachments on bug 182930: 64162 | 64576 | 64656 | 64691 | 64707 | 65764