Attachment #18249 for bug #72258




package org.eclipse.jdt.internal.core;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.jdt.core.IJavaElement;

	this.childrenCache = new HashMap(DEFAULT_CHILDREN_SIZE);
}

/*
 * Ensures there is enough room in each ElementCache to put the given new elements.
 */
protected void ensureSpaceLimit(Map newElements) {
	int rootSize = 0;
	IJavaElement project = null;
	int pkgSize = 0;
	IJavaElement root = null;
	int openableSize = 0;
	IJavaElement pkg = null;
	Iterator iterator = newElements.keySet().iterator();
	while (iterator.hasNext()) {
		IJavaElement element = (IJavaElement) iterator.next();
		switch (element.getElementType()) {
			case IJavaElement.PACKAGE_FRAGMENT_ROOT:
				project = element.getParent();
				rootSize++;
				break;
			case IJavaElement.PACKAGE_FRAGMENT:
				root = element.getParent();
				pkgSize++;
				break;
			case IJavaElement.COMPILATION_UNIT:
			case IJavaElement.CLASS_FILE:
				pkg = element.getParent();
				openableSize++;
				break;
		}
	}
	this.rootCache.ensureSpaceLimit(rootSize, project);
	this.pkgCache.ensureSpaceLimit(pkgSize, root);
	this.openableCache.ensureSpaceLimit(openableSize, pkg);
}

/*
 * The given element is being removed.
 * Ensures that the corresponding children cache's space limit is reset if this was the parent
 * that increased the space limit.
 */
protected void resetSpaceLimit(IJavaElement element) {
	switch (element.getElementType()) {
		case IJavaElement.JAVA_PROJECT:
			this.rootCache.resetSpaceLimit(DEFAULT_ROOT_SIZE, element);
			break;
		case IJavaElement.PACKAGE_FRAGMENT_ROOT:
			this.pkgCache.resetSpaceLimit(DEFAULT_PKG_SIZE, element);
			break;
		case IJavaElement.PACKAGE_FRAGMENT:
			this.openableCache.resetSpaceLimit(DEFAULT_OPENABLE_SIZE, element);
			break;
	}
}
		
/**
 *  Returns the info for the element.
 */

			break;
		case IJavaElement.JAVA_PROJECT:
			this.projectCache.put(element, info);
			this.rootCache.ensureSpaceLimit(((JavaElementInfo) info).children.length, element);
			break;
		case IJavaElement.PACKAGE_FRAGMENT_ROOT:
			this.rootCache.put(element, info);
			this.pkgCache.ensureSpaceLimit(((JavaElementInfo) info).children.length, element);
			break;
		case IJavaElement.PACKAGE_FRAGMENT:
			this.pkgCache.put(element, info);
			this.openableCache.ensureSpaceLimit(((JavaElementInfo) info).children.length, element);
			break;
		case IJavaElement.COMPILATION_UNIT:
		case IJavaElement.CLASS_FILE:

			break;
		case IJavaElement.JAVA_PROJECT:
			this.projectCache.remove(element);
			this.rootCache.resetSpaceLimit(DEFAULT_ROOT_SIZE, element);
			break;
		case IJavaElement.PACKAGE_FRAGMENT_ROOT:
			this.rootCache.remove(element);
			this.pkgCache.resetSpaceLimit(DEFAULT_PKG_SIZE, element);
			break;
		case IJavaElement.PACKAGE_FRAGMENT:
			this.pkgCache.remove(element);
			this.openableCache.resetSpaceLimit(DEFAULT_OPENABLE_SIZE, element);
			break;
		case IJavaElement.COMPILATION_UNIT:
		case IJavaElement.CLASS_FILE:




							pkgPath = pkgPath.removeLastSegments(1);
						}
						String[] pkgName = pkgPath.segments();
						if (pkgName.length != 0 && JavaConventions.validatePackageName(Util.packageName(pkgPath)).getSeverity() == IStatus.ERROR) {
							return null;
						}
						return root.getPackageFragment(pkgName);

			}
		}
		
		// ensure that the elements that are being added have enough room
		this.cache.ensureSpaceLimit(newElements);
		
		Iterator iterator = newElements.keySet().iterator();
		while (iterator.hasNext()) {
			IJavaElement element = (IJavaElement)iterator.next();

					}
				}
				this.cache.removeInfo(element);
				this.cache.resetSpaceLimit(element);
				if (wasVerbose) {
					System.out.println(this.cache.toStringFillingRation("-> ")); //$NON-NLS-1$
				}

Lines 729-735 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelOperation.java (-1 / +6 lines)
729	if (!(openable instanceof CompilationUnit) \|\| !((CompilationUnit) openable).isWorkingCopy()) { // a working copy must remain a child of its parent even after a move	729	if (!(openable instanceof CompilationUnit) \|\| !((CompilationUnit) openable).isWorkingCopy()) { // a working copy must remain a child of its parent even after a move
730	((JavaElement) openable.getParent()).close();	730	((JavaElement) openable.getParent()).close();
731	}	731	}
732	((JavaProject) element.getJavaProject()).resetCaches();	732	switch (element.getElementType()) {
		733	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
		734	case IJavaElement.PACKAGE_FRAGMENT:
		735	((JavaProject) element.getJavaProject()).resetCaches();
		736	break;
		737	}
733	}	738	}
734		739
735	// fire only iff:	740	// fire only iff:

Return to bug 72258

Lines 11-17 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelCache.java (-54 / +6 lines)
11	package org.eclipse.jdt.internal.core;	11	package org.eclipse.jdt.internal.core;
12	import java.text.NumberFormat;	12	import java.text.NumberFormat;
13	import java.util.HashMap;	13	import java.util.HashMap;
14	import java.util.Iterator;
15	import java.util.Map;	14	import java.util.Map;
16		15
17	import org.eclipse.jdt.core.IJavaElement;	16	import org.eclipse.jdt.core.IJavaElement;
Lines 65-123 Link Here
65	this.childrenCache = new HashMap(DEFAULT_CHILDREN_SIZE);	64	this.childrenCache = new HashMap(DEFAULT_CHILDREN_SIZE);
66	}	65	}
67		66
68	/*
69	* Ensures there is enough room in each ElementCache to put the given new elements.
70	*/
71	protected void ensureSpaceLimit(Map newElements) {
72	int rootSize = 0;
73	IJavaElement project = null;
74	int pkgSize = 0;
75	IJavaElement root = null;
76	int openableSize = 0;
77	IJavaElement pkg = null;
78	Iterator iterator = newElements.keySet().iterator();
79	while (iterator.hasNext()) {
80	IJavaElement element = (IJavaElement) iterator.next();
81	switch (element.getElementType()) {
82	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
83	project = element.getParent();
84	rootSize++;
85	break;
86	case IJavaElement.PACKAGE_FRAGMENT:
87	root = element.getParent();
88	pkgSize++;
89	break;
90	case IJavaElement.COMPILATION_UNIT:
91	case IJavaElement.CLASS_FILE:
92	pkg = element.getParent();
93	openableSize++;
94	break;
95	}
96	}
97	this.rootCache.ensureSpaceLimit(rootSize, project);
98	this.pkgCache.ensureSpaceLimit(pkgSize, root);
99	this.openableCache.ensureSpaceLimit(openableSize, pkg);
100	}
101
102	/*
103	* The given element is being removed.
104	* Ensures that the corresponding children cache's space limit is reset if this was the parent
105	* that increased the space limit.
106	*/
107	protected void resetSpaceLimit(IJavaElement element) {
108	switch (element.getElementType()) {
109	case IJavaElement.JAVA_PROJECT:
110	this.rootCache.resetSpaceLimit(DEFAULT_ROOT_SIZE, element);
111	break;
112	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
113	this.pkgCache.resetSpaceLimit(DEFAULT_PKG_SIZE, element);
114	break;
115	case IJavaElement.PACKAGE_FRAGMENT:
116	this.openableCache.resetSpaceLimit(DEFAULT_OPENABLE_SIZE, element);
117	break;
118	}
119	}
120
121	/**	67	/**
122	* Returns the info for the element.	68	* Returns the info for the element.
123	*/	69	*/
Lines 171-182 Link Here
171	break;	117	break;
172	case IJavaElement.JAVA_PROJECT:	118	case IJavaElement.JAVA_PROJECT:
173	this.projectCache.put(element, info);	119	this.projectCache.put(element, info);
		120	this.rootCache.ensureSpaceLimit(((JavaElementInfo) info).children.length, element);
174	break;	121	break;
175	case IJavaElement.PACKAGE_FRAGMENT_ROOT:	122	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
176	this.rootCache.put(element, info);	123	this.rootCache.put(element, info);
		124	this.pkgCache.ensureSpaceLimit(((JavaElementInfo) info).children.length, element);
177	break;	125	break;
178	case IJavaElement.PACKAGE_FRAGMENT:	126	case IJavaElement.PACKAGE_FRAGMENT:
179	this.pkgCache.put(element, info);	127	this.pkgCache.put(element, info);
		128	this.openableCache.ensureSpaceLimit(((JavaElementInfo) info).children.length, element);
180	break;	129	break;
181	case IJavaElement.COMPILATION_UNIT:	130	case IJavaElement.COMPILATION_UNIT:
182	case IJavaElement.CLASS_FILE:	131	case IJavaElement.CLASS_FILE:
Lines 196-207 Link Here
196	break;	145	break;
197	case IJavaElement.JAVA_PROJECT:	146	case IJavaElement.JAVA_PROJECT:
198	this.projectCache.remove(element);	147	this.projectCache.remove(element);
		148	this.rootCache.resetSpaceLimit(DEFAULT_ROOT_SIZE, element);
199	break;	149	break;
200	case IJavaElement.PACKAGE_FRAGMENT_ROOT:	150	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
201	this.rootCache.remove(element);	151	this.rootCache.remove(element);
		152	this.pkgCache.resetSpaceLimit(DEFAULT_PKG_SIZE, element);
202	break;	153	break;
203	case IJavaElement.PACKAGE_FRAGMENT:	154	case IJavaElement.PACKAGE_FRAGMENT:
204	this.pkgCache.remove(element);	155	this.pkgCache.remove(element);
		156	this.openableCache.resetSpaceLimit(DEFAULT_OPENABLE_SIZE, element);
205	break;	157	break;
206	case IJavaElement.COMPILATION_UNIT:	158	case IJavaElement.COMPILATION_UNIT:
207	case IJavaElement.CLASS_FILE:	159	case IJavaElement.CLASS_FILE:

Lines 480-486 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (-5 / +1 lines)
480	pkgPath = pkgPath.removeLastSegments(1);	480	pkgPath = pkgPath.removeLastSegments(1);
481	}	481	}
482	String[] pkgName = pkgPath.segments();	482	String[] pkgName = pkgPath.segments();
483	if (pkgName == null \|\| JavaConventions.validatePackageName(Util.packageName(pkgPath)).getSeverity() == IStatus.ERROR) {	483	if (pkgName.length != 0 && JavaConventions.validatePackageName(Util.packageName(pkgPath)).getSeverity() == IStatus.ERROR) {
484	return null;	484	return null;
485	}	485	}
486	return root.getPackageFragment(pkgName);	486	return root.getPackageFragment(pkgName);
Lines 1511-1519 Link Here
1511	}	1511	}
1512	}	1512	}
1513		1513
1514	// ensure that the elements that are being added have enough room
1515	this.cache.ensureSpaceLimit(newElements);
1516
1517	Iterator iterator = newElements.keySet().iterator();	1514	Iterator iterator = newElements.keySet().iterator();
1518	while (iterator.hasNext()) {	1515	while (iterator.hasNext()) {
1519	IJavaElement element = (IJavaElement)iterator.next();	1516	IJavaElement element = (IJavaElement)iterator.next();
Lines 1651-1657 Link Here
1651	}	1648	}
1652	}	1649	}
1653	this.cache.removeInfo(element);	1650	this.cache.removeInfo(element);
1654	this.cache.resetSpaceLimit(element);
1655	if (wasVerbose) {	1651	if (wasVerbose) {
1656	System.out.println(this.cache.toStringFillingRation("-> ")); //$NON-NLS-1$	1652	System.out.println(this.cache.toStringFillingRation("-> ")); //$NON-NLS-1$
1657	}	1653	}