Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2009 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 Contributors: IBM Corporation - initial API and implementation /
 
 package org.eclipse.jdt.internal.core;
 
 import java.util.Map;
 
 import  org.eclipse.core.resources.IContainer;
 import  org.eclipse.core.resources.IResource;
 import  org.eclipse.core.runtime.CoreException;
 import  org.eclipse.core.runtime.IPath;
Info for IJavaProject.

Note: getChildren() returns all of the IPackageFragmentRoots specified on the classpath for the project. This can include roots external to the project. See JavaProject#getAllPackageFragmentRoots() and JavaProject#getPackageFragmentRoots(). To get only the IPackageFragmentRoots that are internal to the project, use JavaProject#getChildren().

 
 
 /* package */
 
 	static final IPackageFragmentRoot[] NO_ROOTS = new IPackageFragmentRoot[0];
 
 	static class ProjectCache {
 		ProjectCache(IPackageFragmentRoot[] allPkgFragmentRootsCacheMap rootToResolvedEntriesMap pkgFragmentsCaches) {
 			this. = allPkgFragmentRootsCache;
 			this. = rootToResolvedEntries;
 			this. = pkgFragmentsCaches;
 		}
 
 		/*
 		 * A cache of all package fragment roots of this project.
 		 */
 
 		/*
 		 * 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))
 		 */
 
 		/*
 		 * A cache of package fragments for each package fragment root of this project
 		 * (a map from IPackageFragmentRoot to a set of String[] (the package name))
 		 */
 
 	}

A array with all the non-java resources contained by this PackageFragment
 
 	private Object[] nonJavaResources;
 
 
 	/*
 	 * Adds the given name and its super names to the given set
 	 * (e.g. for {"a", "b", "c"}, adds {"a", "b", "c"}, {"a", "b"}, and {"a"})
 	 */
 	static void addSuperPackageNames(String[] pkgNameHashtableOfArrayToObject packageFragments) {
 		for (int i = pkgName.length-1; i > 0; i--) {
 			if (packageFragments.getKey(pkgNamei) == null) {
 				System.arraycopy(pkgName, 0, pkgName = new String[i], 0, i);
 				packageFragments.put(pkgName);
 			}
 		}
 	}

Create and initialize a new instance of the receiver
 
 	public JavaProjectElementInfo() {
 		this. = null;
 	}

Compute the non-java resources contained in this java project.
 
 	private Object[] computeNonJavaResources(JavaProject project) {
 
 		// determine if src == project and/or if bin == project
		IPath projectPath = project.getProject().getFullPath();
		boolean srcIsProject = false;
		boolean binIsProject = false;
		char[][] inclusionPatterns = null;
		char[][] exclusionPatterns = null;
		IPath projectOutput = null;
		boolean isClasspathResolved = true;
		try {
			IClasspathEntry entry = project.getClasspathEntryFor(projectPath);
			if (entry != null) {
				srcIsProject = true;
				inclusionPatterns = ((ClasspathEntry)entry).fullInclusionPatternChars();
				exclusionPatterns = ((ClasspathEntry)entry).fullExclusionPatternChars();
			}
			projectOutput = project.getOutputLocation();
			binIsProject = projectPath.equals(projectOutput);
catch (JavaModelException e) {
			isClasspathResolved = false;
		}
		Object[] resources = new IResource[5];
		int resourcesCounter = 0;
		try {
			IResource[] members = ((IContainer) project.getResource()).members();
			int length = members.length;
			if (length > 0) {
				String sourceLevel = project.getOption(.true);
				String complianceLevel = project.getOption(.true);
				IClasspathEntry[] classpath = project.getResolvedClasspath();
				for (int i = 0; i < lengthi++) {
					IResource res = members[i];
					switch (res.getType()) {
						case IResource.FILE :
							IPath resFullPath = res.getFullPath();
							String resName = res.getName();
							// ignore a jar file on the classpath
							if (isClasspathResolved && 
									isClasspathEntryOrOutputLocation(resFullPathres.getLocation()/* see https://bugs.eclipse.org/bugs/show_bug.cgi?id=244406 */classpathprojectOutput)) {
								break;
							}
							// ignore .java file if src == project
							if (srcIsProject
									&& Util.isValidCompilationUnitName(resNamesourceLevelcomplianceLevel)
									&& !Util.isExcluded(resinclusionPatternsexclusionPatterns)) {
								break;
							}
							// ignore .class file if bin == project
							if (binIsProject && Util.isValidClassFileName(resNamesourceLevelcomplianceLevel)) {
								break;
							}
							// else add non java resource
							if (resources.length == resourcesCounter) {
								// resize
								System.arraycopy(
										resources,
										0,
										(resources = new IResource[resourcesCounter * 2]),
										0,
										resourcesCounter);
							}
							resources[resourcesCounter++] = res;
							break;
						case IResource.FOLDER :
							resFullPath = res.getFullPath();
							// ignore non-excluded folders on the classpath or that correspond to an output location
							if ((srcIsProject && !Util.isExcluded(resinclusionPatternsexclusionPatterns) && Util.isValidFolderNameForPackage(res.getName(), sourceLevelcomplianceLevel))
									|| (isClasspathResolved && isClasspathEntryOrOutputLocation(resFullPathres.getLocation(), classpathprojectOutput))) {
								break;
							}
							// else add non java resource
							if (resources.length == resourcesCounter) {
								// resize
								System.arraycopy(
										resources,
										0,
										(resources = new IResource[resourcesCounter * 2]),
										0,
										resourcesCounter);
							}
							resources[resourcesCounter++] = res;
					}
				}
			}
			if (resources.length != resourcesCounter) {
				System.arraycopy(
					resources,
					0,
					(resources = new IResource[resourcesCounter]),
					0,
					resourcesCounter);
			}
catch (CoreException e) {
			resources = ;
			resourcesCounter = 0;
		}
		return resources;
	}
		ProjectCache cache = this.;
		if (cache == null) {
			Map reverseMap = new HashMap(3);
			try {
				roots = project.getAllPackageFragmentRoots(reverseMap);
catch (JavaModelException e) {
				// project does not exist: cannot happen since this is the info of the project
				roots = new IPackageFragmentRoot[0];
				reverseMap.clear();
			}
			HashMap rootInfos = JavaModelManager.getJavaModelManager()..;
			HashMap pkgFragmentsCaches = new HashMap();
			int length = roots.length;
			JavaModelManager  manager = JavaModelManager.getJavaModelManager();
			for (int i = 0; i < lengthi++) {
				IPackageFragmentRoot root = roots[i];
				DeltaProcessor.RootInfo rootInfo = (DeltaProcessor.RootInforootInfos.get(root.getPath());
				if (rootInfo == null || rootInfo.project.equals(project)) {
					// ensure that an identical root is used (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=217059 )
					roots[i] = root = (IPackageFragmentRootmanager.getExistingElement(root);
					// compute fragment cache
					HashSetOfArray fragmentsCache = new HashSetOfArray();
					initializePackageNames(rootfragmentsCache);
					pkgFragmentsCaches.put(rootfragmentsCache);
				}
			}
			cache = new ProjectCache(rootsreverseMappkgFragmentsCaches);
			this. = cache;
		}
		return cache;
	}

Returns an array of non-java resources contained in the receiver.
		if (this. == null) {
		}
		return this.;
	}
	private void initializePackageNames(IPackageFragmentRoot rootHashSetOfArray fragmentsCache) {
		IJavaElement[] frags = null;
		try {
			if (!root.isOpen()) {
				frags = info.children;
else
				frags = root.getChildren();
catch (JavaModelException e) {
			// root doesn't exist: ignore
			return;
		}
		for (int j = 0, length = frags.lengthj < lengthj++) {
			fragmentsCache.add(((PackageFragmentfrags[j]).);
		}
	}
	/*
	 * Returns whether the given path is a classpath entry or an output location.
	 */
	private boolean isClasspathEntryOrOutputLocation(IPath path, IPath locationIClasspathEntry[] resolvedClasspath, IPath projectOutput) {
		if (projectOutput.equals(path)) return true;
		for (int i = 0, length = resolvedClasspath.lengthi < lengthi++) {
			IClasspathEntry entry = resolvedClasspath[i];
			IPath entryPath;
			if ((entryPath = entry.getPath()).equals(path) || entryPath.equals(location)) {
				return true;
			}
			IPath output;
			if ((output = entry.getOutputLocation()) != null && output.equals(path)) {
				return true;
			}
		}
		return false;
	}
	/*
	 * Creates a new name lookup for this project info.
	 * The given project is assumed to be the handle of this info.
	 * This name lookup first looks in the given working copies.
	 */
	NameLookup newNameLookup(JavaProject projectICompilationUnit[] workingCopies) {
		ProjectCache cache = getProjectCache(project);
		HashtableOfArrayToObject allPkgFragmentsCache = cache.allPkgFragmentsCache;
		if (allPkgFragmentsCache == null) {
			HashMap rootInfos = JavaModelManager.getJavaModelManager()..;
			IPackageFragmentRoot[] allRoots = cache.allPkgFragmentRootsCache;
			int length = allRoots.length;
			allPkgFragmentsCache = new HashtableOfArrayToObject();
			for (int i = 0; i < lengthi++) {
				IPackageFragmentRoot root = allRoots[i];
				DeltaProcessor.RootInfo rootInfo = (DeltaProcessor.RootInforootInfos.get(root.getPath());
				JavaProject rootProject = rootInfo == null ? project : rootInfo.project;
				HashSetOfArray fragmentsCache;
				if (rootProject.equals(project)) {
					// retrieve package fragments cache from this project
					fragmentsCache = (HashSetOfArraycache.pkgFragmentsCaches.get(root);
else {
					// retrieve package fragments  cache from the root's project
					ProjectCache rootProjectCache;
					try {
						rootProjectCache = rootProject.getProjectCache();
catch (JavaModelException e) {
						// project doesn't exit
						continue;
					}
					fragmentsCache = (HashSetOfArrayrootProjectCache.pkgFragmentsCaches.get(root);
				}
				if (fragmentsCache == null) { // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=183833
					fragmentsCache = new HashSetOfArray();
					initializePackageNames(rootfragmentsCache);
				}
				Object[][] set = fragmentsCache.set;
				for (int j = 0, length2 = set.lengthj < length2j++) {
					String[] pkgName = (String[]) set[j];
					if (pkgName == null)
						continue;
					Object existing = allPkgFragmentsCache.get(pkgName);
					if (existing == null || existing == ) {
						allPkgFragmentsCache.put(pkgNameroot);
						// ensure super packages (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
						// are also in the map
						addSuperPackageNames(pkgNameallPkgFragmentsCache);
else {
						if (existing instanceof PackageFragmentRoot) {
							allPkgFragmentsCache.put(pkgNamenew IPackageFragmentRoot[] {(PackageFragmentRootexistingroot});
else {
							IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) existing;
							int rootLength = roots.length;
							System.arraycopy(roots, 0, roots = new IPackageFragmentRoot[rootLength+1], 0, rootLength);
							roots[rootLength] = root;
							allPkgFragmentsCache.put(pkgNameroots);
						}
					}
				}
			}
			cache.allPkgFragmentsCache = allPkgFragmentsCache;
		}
		return new NameLookup(cache.allPkgFragmentRootsCachecache.allPkgFragmentsCacheworkingCopiescache.rootToResolvedEntries);
	}
	/*
	 * Reset the package fragment roots and package fragment caches
	 */
	void resetCaches() {
		this. = null;
	}

Set the fNonJavaResources to res value
	void setNonJavaResources(Object[] resources) {
		this. = resources;
	}
New to GrepCode? Check out our FAQ X