本文整理汇总了Java中org.eclipse.jdt.core.IClasspathEntry.CPE_PROJECT属性的典型用法代码示例。如果您正苦于以下问题:Java IClasspathEntry.CPE_PROJECT属性的具体用法?Java IClasspathEntry.CPE_PROJECT怎么用?Java IClasspathEntry.CPE_PROJECT使用的例子?那么, 这里精选的属性代码示例或许可以为您提供帮助。您也可以进一步了解该属性所在类org.eclipse.jdt.core.IClasspathEntry
的用法示例。
在下文中一共展示了IClasspathEntry.CPE_PROJECT属性的7个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: getProjectClassPath
public static void getProjectClassPath(IJavaProject project, List<File> dst) throws Exception {
IRuntimeClasspathEntry [] rentries = JavaRuntime.computeUnresolvedRuntimeClasspath(project);
for (IRuntimeClasspathEntry entry : rentries) {
switch (entry.getType()) {
case IClasspathEntry.CPE_SOURCE:
break;
case IClasspathEntry.CPE_PROJECT:
break;
case IClasspathEntry.CPE_LIBRARY:
break;
case IClasspathEntry.CPE_VARIABLE:
// JRE like entries
IRuntimeClasspathEntry [] variableEntries = JavaRuntime.resolveRuntimeClasspathEntry(entry, project);
break;
case IClasspathEntry.CPE_CONTAINER:
IRuntimeClasspathEntry [] containerEntries = JavaRuntime.resolveRuntimeClasspathEntry(entry, project);
for (IRuntimeClasspathEntry containerentry : containerEntries) {
dst.add(new File (containerentry.getLocation()));
}
break;
default:
throw new Exception("unsupported classpath entry "+entry);
}
}
}
示例2: addMavenClasspathEntries
private void addMavenClasspathEntries(Set<IRuntimeClasspathEntry> resolved,
IRuntimeClasspathEntry runtimeClasspathEntry, ILaunchConfiguration configuration, int scope,
IProgressMonitor monitor) throws CoreException {
IJavaProject javaProject = JavaRuntime.getJavaProject(configuration);
MavenJdtPlugin plugin = MavenJdtPlugin.getDefault();
IClasspathManager buildpathManager = plugin.getBuildpathManager();
IClasspathEntry[] cp = buildpathManager.getClasspath(javaProject.getProject(), scope, false, monitor);
for(IClasspathEntry entry : cp) {
switch(entry.getEntryKind()) {
case IClasspathEntry.CPE_PROJECT:
addProjectEntries(resolved, entry.getPath(), scope, getArtifactClassifier(entry), configuration, monitor);
break;
case IClasspathEntry.CPE_LIBRARY:
resolved.add(JavaRuntime.newArchiveRuntimeClasspathEntry(entry.getPath()));
break;
// case IClasspathEntry.CPE_SOURCE:
// resolved.add(newSourceClasspathEntry(javaProject, cp[i]));
// break;
}
}
}
示例3: addToClassPath
public static void addToClassPath(IResource res, int type, IJavaProject javaProject, IProgressMonitor monitor) throws JavaModelException
{
Set<IClasspathEntry> entries = new HashSet<IClasspathEntry>(Arrays.asList(javaProject.getRawClasspath()));
IClasspathEntry entry = null;
switch (type) {
case IClasspathEntry.CPE_SOURCE:
entry = JavaCore.newSourceEntry(res.getFullPath());
break;
case IClasspathEntry.CPE_LIBRARY:
entry = JavaCore.newLibraryEntry(res.getFullPath(), null, null, true);
break;
case IClasspathEntry.CPE_PROJECT:
entry = JavaCore.newProjectEntry(res.getFullPath(), true);
break;
}
entries.add(entry);
setClasspath(entries.toArray(new IClasspathEntry[entries.size()]), javaProject, monitor);
}
示例4: addMissingProjectDependencies
private void addMissingProjectDependencies(IProgressMonitor monitor, IProject project, ExtensionHolder extHolder) throws JavaModelException
{
IJavaProject javaProject = JavaCore.create(project);
IClasspathEntry[] classPathEntries = javaProject.getRawClasspath();
if (!extHolder.getDependentExtensions().isEmpty()) {
for (String ext : extHolder.getDependentExtensions()) {
boolean found = false;
for (IClasspathEntry classpathEntry : classPathEntries) {
// fix jar files
if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
if (classpathEntry.getPath().toString().replaceFirst("/", "").equalsIgnoreCase(ext)) {
found = true;
break;
}
}
}
if (!found) {
IProject dependentProject = ResourcesPlugin.getWorkspace()
.getRoot().getProject(ext);
if (dependentProject.exists() && dependentProject.isOpen())
{
FixProjectsUtils.addToClassPath(dependentProject, IClasspathEntry.CPE_PROJECT, javaProject, monitor);
}
}
}
}
}
示例5: createResourceLoader
private ResourceLoader createResourceLoader(final IProject project) {
if (project != null) {
IJavaProject javaProject = JavaCore.create(project);
if (javaProject != null) {
IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
try {
IClasspathEntry[] classPathEntries = javaProject.getResolvedClasspath(true);
URL[] urls = new URL[classPathEntries.length];
for (int i = 0; i < classPathEntries.length; i++) {
IClasspathEntry entry = classPathEntries[i];
IPath path = null;
switch (entry.getEntryKind()) {
case IClasspathEntry.CPE_PROJECT:
IJavaProject requiredProject = JavaCore.create((IProject) workspaceRoot.findMember(entry.getPath()));
if (requiredProject != null) {
path = workspaceRoot.findMember(requiredProject.getOutputLocation()).getLocation();
}
break;
case IClasspathEntry.CPE_SOURCE:
path = workspaceRoot.findMember(entry.getPath()).getLocation();
break;
default:
path = entry.getPath();
break;
}
if (path != null) {
urls[i] = path.toFile().toURI().toURL();
}
}
ClassLoader parentClassLoader = javaProject.getClass().getClassLoader();
URLClassLoader classLoader = new URLClassLoader(urls, parentClassLoader);
return new CustomResourceLoader(classLoader);
} catch (MalformedURLException | CoreException e) {
LOG.warn("Failed to create class loader for project " + project.getName(), e);
}
}
}
return new ResourceLoaderImpl(GeneratorSupport.class.getClassLoader());
}
示例6: addDependencies
private void addDependencies(final IProgressMonitor monitor, final ICanceler canceler, final WorkspaceBuilder builder)
throws JavaModelException,
InterruptedException {
for (final IJavaProject javaProject : this.model.getJavaProjects()) {
final String message = MessageFormat.format("scanne dependencies for project {0}", javaProject.getElementName()); //$NON-NLS-1$
this.logger.log(Level.INFO, message);
monitor.subTask(message);
final Project project = builder.getProject(javaProject.getPath().toPortableString());
if (project == null) {
continue;
}
final Set<ILibrary> libraries = new HashSet<>();
ClasspathCollector.collect(canceler, libraries, project);
for (final IClasspathEntry classpathEntry : javaProject.getRawClasspath()) {
if (canceler.isCanceled()) {
throw new InterruptedException();
}
final int entryKind = classpathEntry.getEntryKind();
switch (entryKind) {
case IClasspathEntry.CPE_LIBRARY:
case IClasspathEntry.CPE_PROJECT: {
final org.eclipse.core.runtime.IPath path = classpathEntry.getPath();
final Library library = builder.getLibrary(path.toPortableString());
if (library == null || libraries.contains(library)) {
continue;
}
ClasspathCollector.collect(canceler, libraries, library);
if (libraries.contains(project)) {
final String submessage =
MessageFormat.format("dependencies for project {0} builds cycle over library {1}", //$NON-NLS-1$
javaProject.getElementName(), library.getName());
this.logger.log(Level.ERROR, submessage);
this.logger.log(Level.ERROR, ObjectUtilities.toString(library));
throw new JavaModelException(new Exception(submessage), IStatus.ERROR);
}
libraries.add(library);
project.getDependencies().add(new Dependency(library, classpathEntry.isExported()));
break;
}
case IClasspathEntry.CPE_CONTAINER: {
break;
}
case IClasspathEntry.CPE_SOURCE: {
break;
}
case IClasspathEntry.CPE_VARIABLE: {
break;
}
default:
break;
}
project.setClasspath(libraries);
}
}
}
示例7: addProjectEntries
protected void addProjectEntries(Set<IRuntimeClasspathEntry> resolved, IPath path, int scope, String classifier,
ILaunchConfiguration launchConfiguration, final IProgressMonitor monitor) throws CoreException {
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject project = root.getProject(path.segment(0));
IMavenProjectFacade projectFacade = projectManager.create(project, monitor);
if(projectFacade == null) {
return;
}
ResolverConfiguration configuration = projectFacade.getResolverConfiguration();
if(configuration == null) {
return;
}
IJavaProject javaProject = JavaCore.create(project);
boolean projectResolved = false;
for(IClasspathEntry entry : javaProject.getRawClasspath()) {
IRuntimeClasspathEntry rce = null;
switch(entry.getEntryKind()) {
case IClasspathEntry.CPE_SOURCE:
if(!projectResolved) {
IMavenClassifierManager mavenClassifierManager = MavenJdtPlugin.getDefault().getMavenClassifierManager();
IClassifierClasspathProvider classifierClasspathProvider = mavenClassifierManager
.getClassifierClasspathProvider(projectFacade, classifier);
if(IClasspathManager.CLASSPATH_TEST == scope) {
classifierClasspathProvider.setTestClasspath(resolved, projectFacade, monitor);
} else {
classifierClasspathProvider.setRuntimeClasspath(resolved, projectFacade, monitor);
}
projectResolved = true;
}
break;
case IClasspathEntry.CPE_CONTAINER:
IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
if(container != null && !MavenClasspathHelpers.isMaven2ClasspathContainer(entry.getPath())) {
switch(container.getKind()) {
case IClasspathContainer.K_APPLICATION:
rce = JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(),
IRuntimeClasspathEntry.USER_CLASSES, javaProject);
break;
// case IClasspathContainer.K_DEFAULT_SYSTEM:
// unresolved.add(JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(), IRuntimeClasspathEntry.STANDARD_CLASSES, javaProject));
// break;
// case IClasspathContainer.K_SYSTEM:
// unresolved.add(JavaRuntime.newRuntimeContainerClasspathEntry(container.getPath(), IRuntimeClasspathEntry.BOOTSTRAP_CLASSES, javaProject));
// break;
}
}
break;
case IClasspathEntry.CPE_LIBRARY:
rce = JavaRuntime.newArchiveRuntimeClasspathEntry(entry.getPath());
break;
case IClasspathEntry.CPE_VARIABLE:
if(!JavaRuntime.JRELIB_VARIABLE.equals(entry.getPath().segment(0))) {
rce = JavaRuntime.newVariableRuntimeClasspathEntry(entry.getPath());
}
break;
case IClasspathEntry.CPE_PROJECT:
IProject res = root.getProject(entry.getPath().segment(0));
if(res != null) {
IJavaProject otherProject = JavaCore.create(res);
if(otherProject != null) {
rce = JavaRuntime.newDefaultProjectClasspathEntry(otherProject);
}
}
break;
default:
break;
}
if(rce != null) {
addStandardClasspathEntries(resolved, rce, launchConfiguration);
}
}
}