Java JavaProject类代码示例

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
/**
 * Removes an IJavaElement's resource. Retries if deletion failed (e.g. because the indexer still
 * locks the file).
 *
 * @param elem the element to delete
 * @throws CoreException if operation failed
 * @see #ASSERT_NO_MIXED_LINE_DELIMIERS
 */
public static void delete(final IJavaElement elem) throws CoreException {
  //		if (ASSERT_NO_MIXED_LINE_DELIMIERS)
  //			MixedLineDelimiterDetector.assertNoMixedLineDelimiters(elem);
  if (elem instanceof JavaProject) {
    ((JavaProject) elem).close();
    JavaModelManager.getJavaModelManager().removePerProjectInfo((JavaProject) elem, true);
  }
  JavaModelManager.getJavaModelManager().resetTemporaryCache();
  IWorkspaceRunnable runnable =
      new IWorkspaceRunnable() {
        public void run(IProgressMonitor monitor) throws CoreException {
          //				performDummySearch();
          if (elem instanceof IJavaProject) {
            IJavaProject jproject = (IJavaProject) elem;
            jproject.setRawClasspath(
                new IClasspathEntry[0], jproject.getProject().getFullPath(), null);
          }
          delete(elem.getResource());
        }
      };
  ResourcesPlugin.getWorkspace().run(runnable, null);
  //		emptyDisplayLoop();
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
@Test(expected = SearchException.class)
public void testSearchCantFindElement() throws Exception {
  IPackageFragmentRoot root =
      ((JavaProject) JUnitSourceSetup.getProject())
          .getPackageFragmentRoot(new Path(JUnitSourceSetup.SRC_CONTAINER));
  IPackageFragment packageFragment = root.createPackageFragment("che", true, null);
  StringBuilder a = new StringBuilder();
  a.append("package che;\n");
  a.append("public class A{}\n");
  ICompilationUnit compilationUnitA =
      packageFragment.createCompilationUnit("A.java", a.toString(), true, null);
  SearchManager manager = new SearchManager();
  manager.findUsage(
      JUnitSourceSetup.getProject(),
      compilationUnitA.getResource().getFullPath().toOSString(),
      24);
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
/**
 * Trigger addition of the entire content of a project Note: the actual operation is performed in
 * background
 */
public void indexAll(IProject project) {
  //        if (JavaCore.getPlugin() == null) return;

  // Also request indexing of binaries on the classpath
  // determine the new children
  try {
    JavaModel model = JavaModelManager.getJavaModelManager().getJavaModel();
    JavaProject javaProject = (JavaProject) model.getJavaProject(project);
    // only consider immediate libraries - each project will do the same
    // NOTE: force to resolve CP variables before calling indexer - 19303, so that initializers
    // will be run in the current thread.
    IClasspathEntry[] entries = javaProject.getResolvedClasspath();
    for (int i = 0; i < entries.length; i++) {
      IClasspathEntry entry = entries[i];
      if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY)
        indexLibrary(
            entry.getPath(), project, ((ClasspathEntry) entry).getLibraryIndexLocation());
    }
  } catch (JavaModelException e) { // cannot retrieve classpath info
  }

  // check if the same request is not already in the queue
  IndexRequest request = new IndexAllProject(project, this);
  if (!isJobWaiting(request)) request(request);
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
/** Index the content of the given source folder. */
public void indexSourceFolder(
    JavaProject javaProject,
    IPath sourceFolder,
    char[][] inclusionPatterns,
    char[][] exclusionPatterns) {
  IProject project = javaProject.getProject();
  if (this.jobEnd > this.jobStart) {
    // skip it if a job to index the project is already in the queue
    IndexRequest request = new IndexAllProject(project, this);
    if (isJobWaiting(request)) return;
  }

  request(
      new AddFolderToIndex(sourceFolder, project, inclusionPatterns, exclusionPatterns, this));
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
private void rebuildIndex(IndexLocation indexLocation, IPath containerPath) {
  Object target = JavaModelManager.getTarget(containerPath, true);
  if (target == null) return;

  if (JobManager.VERBOSE)
    Util.verbose(
        "-> request to rebuild index: "
            + indexLocation
            + " path: "
            + containerPath); // $NON-NLS-1$ //$NON-NLS-2$

  updateIndexState(indexLocation, REBUILDING_STATE);
  IndexRequest request = null;
  if (target instanceof IProject) {
    IProject p = (IProject) target;
    if (JavaProject.hasJavaNature(p)) request = new IndexAllProject(p, this);
  } else if (target instanceof IFolder) {
    request = new IndexBinaryFolder((IFolder) target, this);
  } else if (target instanceof IFile) {
    request = new AddJarFileToIndex((IFile) target, null, this);
  } else if (target instanceof File) {
    request = new AddJarFileToIndex(containerPath, null, this);
  }
  if (request != null) request(request);
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
/** Remove the content of the given source folder from the index. */
public void removeSourceFolderFromIndex(
    JavaProject javaProject,
    IPath sourceFolder,
    char[][] inclusionPatterns,
    char[][] exclusionPatterns) {
  IProject project = javaProject.getProject();
  if (this.jobEnd > this.jobStart) {
    // skip it if a job to index the project is already in the queue
    IndexRequest request = new IndexAllProject(project, this);
    if (isJobWaiting(request)) return;
  }

  request(
      new RemoveFolderFromIndex(
          sourceFolder, inclusionPatterns, exclusionPatterns, project, this));
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
private PackageFragmentRoot getJarPkgFragmentRoot(
    IPath jarPath, Object target, IJavaProject[] projects) {
  for (int i = 0, projectCount = projects.length; i < projectCount; i++) {
    try {
      JavaProject javaProject = (JavaProject) projects[i];
      IClasspathEntry classpathEnty = javaProject.getClasspathEntryFor(jarPath);
      if (classpathEnty != null) {
        if (target instanceof IFile) {
          // internal jar
          return (PackageFragmentRoot) javaProject.getPackageFragmentRoot((IFile) target);
        } else {
          // external jar
          return (PackageFragmentRoot) javaProject.getPackageFragmentRoot0(jarPath);
        }
      }
    } catch (JavaModelException e) {
      // JavaModelException from getResolvedClasspath - a problem occurred while accessing
      // project: nothing we can do, ignore
    }
  }
  return null;
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
public static IClasspathEntry getNullableRawClasspathEntryForPackageFragmentRoot(
    IPackageFragmentRoot root) throws JavaModelException {

  IClasspathEntry rawEntry = null;
  {
    JavaProject project = (JavaProject) root.getJavaProject();
    // force the reverse rawEntry cache to be populated
    project.getResolvedClasspath(true);
    @SuppressWarnings("rawtypes")
    Map rootPathToRawEntries = project.getPerProjectInfo().rootPathToRawEntries;
    if (rootPathToRawEntries != null) {
      rawEntry = (IClasspathEntry) rootPathToRawEntries.get(root.getPath());
    }
  }
  return rawEntry;
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
public JavaSearchNameEnvironment(IJavaProject javaProject, org.eclipse.jdt.core.ICompilationUnit[] copies) {
	computeClasspathLocations(javaProject.getProject().getWorkspace().getRoot(), (JavaProject) javaProject);
	try {
		int length = copies == null ? 0 : copies.length;
		this.workingCopies = new HashMap(length);
		if (copies != null) {
			for (int i = 0; i < length; i++) {
				org.eclipse.jdt.core.ICompilationUnit workingCopy = copies[i];
				IPackageDeclaration[] pkgs = workingCopy.getPackageDeclarations();
				String pkg = pkgs.length > 0 ? pkgs[0].getElementName() : ""; //$NON-NLS-1$
				String cuName = workingCopy.getElementName();
				String mainTypeName = Util.getNameWithoutJavaLikeExtension(cuName);
				String qualifiedMainTypeName = pkg.length() == 0 ? mainTypeName : pkg.replace('.', '/') + '/' + mainTypeName;
				this.workingCopies.put(qualifiedMainTypeName, workingCopy);
			}
		}
	} catch (JavaModelException e) {
		// working copy doesn't exist: cannot happen
	}
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
/**
 * Locate the matches amongst the possible matches.
 */
protected void locateMatches(JavaProject javaProject, PossibleMatchSet matchSet, int expected) throws CoreException {
	PossibleMatch[] possibleMatches = matchSet.getPossibleMatches(javaProject.getPackageFragmentRoots());
	int length = possibleMatches.length;
	// increase progress from duplicate matches not stored in matchSet while adding...
	if (this.progressMonitor != null && expected>length) {
		this.progressWorked += expected-length;
		this.progressMonitor.worked( expected-length);
	}
	// locate matches (processed matches are limited to avoid problem while using VM default memory heap size)
	for (int index = 0; index < length;) {
		int max = Math.min(MAX_AT_ONCE, length - index);
		locateMatches(javaProject, possibleMatches, index, max);
		index += max;
	}
	this.patternLocator.clear();
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
/**
 * Adds all of the openables defined within this java project to the
 * list.
 */
private void injectAllOpenablesForJavaProject(
	IJavaProject project,
	ArrayList openables) {
	try {
		IPackageFragmentRoot[] devPathRoots =
			((JavaProject) project).getPackageFragmentRoots();
		if (devPathRoots == null) {
			return;
		}
		for (int j = 0; j < devPathRoots.length; j++) {
			IPackageFragmentRoot root = devPathRoots[j];
			injectAllOpenablesForPackageFragmentRoot(root, openables);
		}
	} catch (JavaModelException e) {
		// ignore
	}
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
/**
 * Returns the class path.
 */
public IClasspathEntry[] getClasspath(IPath projectPath) {
	try {
		checkAssertion("a workspace must be open", this.isOpen); //$NON-NLS-1$
		JavaProject javaProject = (JavaProject) JavaCore.create(getProject(projectPath));
		return javaProject.getExpandedClasspath();
		//			IPath[] packageFragmentRootsPath = new IPath[entries.length];
		//			for (int i = 0; i < entries.length; ++i)
		//				packageFragmentRootsPath[i] = entries[i].getPath();
		//			return packageFragmentRootsPath;
	} catch (JavaModelException e) {
		e.printStackTrace();
		checkAssertion("JavaModelException", false); //$NON-NLS-1$
		return null; // not reachable
	}
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
@SuppressWarnings("restriction")
public String takeSnapshot(final IProject project) {
	if (!isProjectKnown(project))
		knowProject(project);
	
	final String zipFileName = project.getName() + "-" + System.currentTimeMillis() + ".zip";
	final String zipFile = parentDirectory + File.separator + zipFileName;
	Job snapshotJob = new Job("Taking snapshot of " + project.getName()) {
		
		@Override
		protected IStatus run(IProgressMonitor monitor) {
			monitor.beginTask("Taking snapshot of " + project.getName(), 1);
			archiveProjectToFile(project, zipFile);
			clientRecorder.recordSnapshot(zipFileName);
			if (JavaProject.hasJavaNature(project)) {
				IJavaProject javaProject = addExternalLibrariesToZipFile(project, zipFile);
				snapshotRequiredProjects(javaProject);
			}
			monitor.done();
			return Status.OK_STATUS;
		}
	};
	snapshotJob.setRule(project);
	snapshotJob.schedule();
	return zipFile;
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
public static IFile getIFile(SourceLocation location) {
  IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();

  for (IProject project : projects) {
    if (project.isOpen() && JavaProject.hasJavaNature(project)) {
      final IJavaProject javaProject = JavaCore.create(project);
      final String filePath = location.getPackageName().replace(".", File.separator);
      try {
        for (IPackageFragmentRoot fragmentRoot : javaProject.getAllPackageFragmentRoots()) {
          if (fragmentRoot.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT && !fragmentRoot.isArchive()) {

            final Path path = Paths.get(fragmentRoot.getResource().getProjectRelativePath().toOSString(), filePath,
                location.getFileName());

            final IFile file = project.getFile(path.toString());

            if (file.exists()) {
              return file;
            }
          }
        }
      } catch (JavaModelException e) {
        MessageDialog.openError(null, "Error occurred", e.getMessage());
      }
    }
  }
  return null;
}
 

import org.eclipse.jdt.internal.core.JavaProject; //导入依赖的package包/类
public void init(IWorkbench workbench, IStructuredSelection selection) {
    Object[] jprojects = selection.toArray();
    selectedJavaProjects = new String[jprojects.length];
    for (int i=0; i<jprojects.length; i++) {
        selectedJavaProjects[i] = ((JavaProject)jprojects[i]).getProject().getName();
    }
}