public IRuntimeClasspathEntry[] computeUnresolvedRuntimeClasspath(IJavaProject project) throws CoreException { return JavaRuntime.computeUnresolvedRuntimeClasspath(project); }
/** * Computes and returns the default unresolved runtime classpath for the given project. * * @param project * the {@link IJavaProject} to compute the unresolved runtime classpath for * @return runtime classpath entries * @exception CoreException * if unable to compute the runtime classpath * @see IRuntimeClasspathEntry * @since 2.0 */ public static IRuntimeClasspathEntry[] computeUnresolvedRuntimeClasspath(IJavaProject project) throws CoreException { return computeUnresolvedRuntimeClasspath(project, false); }
private static IPath[] getClasspath(ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry[] entries= JavaRuntime.computeUnresolvedRuntimeClasspath(configuration); entries= JavaRuntime.resolveRuntimeClasspath(entries, configuration); ArrayList<IPath> userEntries= new ArrayList<>(entries.length); for (int i= 0; i < entries.length; i++) { if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) { String location= entries[i].getLocation(); if (location != null) { IPath entry= Path.fromOSString(location); if (!userEntries.contains(entry)) { userEntries.add(entry); } } } } return userEntries.toArray(new IPath[userEntries.size()]); }
public String[] getResolvedJettyClasspath(ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry[] entries = JavaRuntime .computeUnresolvedRuntimeClasspath(configuration); entries = JavaRuntime.resolveRuntimeClasspath(filterProejctEntries(entries), configuration); List<String> userEntries = new ArrayList<String>(entries.length); Set<String> set = new HashSet<String>(entries.length); for (int i = 0; i < entries.length; i++) { if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) { String location = entries[i].getLocation(); if (location != null) { if (!set.contains(location)) { userEntries.add(location); set.add(location); } } } } return (String[]) userEntries.toArray(new String[userEntries.size()]); }
private static IPath[] getClasspath(ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry[] entries= JavaRuntime.computeUnresolvedRuntimeClasspath(configuration); entries= JavaRuntime.resolveRuntimeClasspath(entries, configuration); ArrayList<IPath> userEntries= new ArrayList<>(entries.length); for (int i= 0; i < entries.length; i++) { if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) { String location= entries[i].getLocation(); if (location != null) { IPath entry= Path.fromOSString(location); if (!userEntries.contains(entry)) { userEntries.add(entry); } } } } return userEntries.toArray(new IPath[userEntries.size()]); }
private static IPath[] getClasspath(ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry[] entries= JavaRuntime.computeUnresolvedRuntimeClasspath(configuration); entries= JavaRuntime.resolveRuntimeClasspath(entries, configuration); ArrayList<IPath> userEntries= new ArrayList<>(entries.length); boolean isModularConfig= JavaRuntime.isModularConfiguration(configuration); for (int i= 0; i < entries.length; i++) { int classPathProperty= entries[i].getClasspathProperty(); if ((!isModularConfig && classPathProperty == IRuntimeClasspathEntry.USER_CLASSES) || (isModularConfig && (classPathProperty == IRuntimeClasspathEntry.CLASS_PATH || classPathProperty == IRuntimeClasspathEntry.MODULE_PATH))) { String location= entries[i].getLocation(); if (location != null) { IPath entry= Path.fromOSString(location); if (!userEntries.contains(entry)) { userEntries.add(entry); } } } } return userEntries.toArray(new IPath[userEntries.size()]); }
private static IPath[] getClasspath(ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry[] entries= JavaRuntime.computeUnresolvedRuntimeClasspath(configuration); entries= JavaRuntime.resolveRuntimeClasspath(entries, configuration); boolean isModularConfig= JavaRuntime.isModularConfiguration(configuration); ArrayList<IPath> userEntries= new ArrayList<>(entries.length); for (int i= 0; i < entries.length; i++) { int classPathProperty= entries[i].getClasspathProperty(); if ((!isModularConfig && classPathProperty == IRuntimeClasspathEntry.USER_CLASSES) || (isModularConfig && (classPathProperty == IRuntimeClasspathEntry.CLASS_PATH || classPathProperty == IRuntimeClasspathEntry.MODULE_PATH))) { String location= entries[i].getLocation(); if (location != null) { IPath entry= Path.fromOSString(location); if (!userEntries.contains(entry)) { userEntries.add(entry); } } } } return userEntries.toArray(new IPath[userEntries.size()]); }
protected IPath[] getClasspath(ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry[] entries= JavaRuntime.computeUnresolvedRuntimeClasspath(configuration); entries= JavaRuntime.resolveRuntimeClasspath(entries, configuration); boolean isModularConfig= JavaRuntime.isModularConfiguration(configuration); ArrayList<IPath> userEntries= new ArrayList<>(entries.length); for (int i= 0; i < entries.length; i++) { int classPathProperty= entries[i].getClasspathProperty(); if ((!isModularConfig && classPathProperty == IRuntimeClasspathEntry.USER_CLASSES) || (isModularConfig && (classPathProperty == IRuntimeClasspathEntry.CLASS_PATH || classPathProperty == IRuntimeClasspathEntry.MODULE_PATH))) { String location= entries[i].getLocation(); if (location != null) { IPath entry= Path.fromOSString(location); if (!userEntries.contains(entry)) { userEntries.add(entry); } } } } return userEntries.toArray(new IPath[userEntries.size()]); }
/** * Override getClasspath so that we also include the load time weaving * aspectpath */ public String[] getClasspath(ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry[] entries = JavaRuntime .computeUnresolvedRuntimeClasspath(configuration); IRuntimeClasspathEntry[] aspectPathEntries = getAspectPathEntries(configuration); entries = JavaRuntime.resolveRuntimeClasspath(entries, configuration); List userEntries = new ArrayList(entries.length + aspectPathEntries.length); for (int i = 0; i < entries.length; i++) { if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) { String location = entries[i].getLocation(); if (location != null) { userEntries.add(location); } } } for (int i = 0; i < aspectPathEntries.length; i++) { String location = aspectPathEntries[i].getLocation(); if (location != null) { userEntries.add(location); } } return (String[]) userEntries.toArray(new String[userEntries.size()]); }
public IRuntimeClasspathEntry[] computeUnresolvedClasspath(ILaunchConfiguration configuration) throws CoreException { boolean useDefault = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_SOURCE_PATH, true); IRuntimeClasspathEntry[] entries = null; if (useDefault) { // the default source lookup path is the classpath of the associated project IJavaProject project = JavaRuntime.getJavaProject(configuration); entries = JavaRuntime.computeUnresolvedRuntimeClasspath(project); } else { // recover persisted source path entries = recoverRuntimePath(configuration, IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH); } return entries; } }
private static String[] computeDefaultRuntimeClassPath(IJavaProject jproject, boolean includeTestScope) throws CoreException { IRuntimeClasspathEntry[] unresolved = JavaRuntime.computeUnresolvedRuntimeClasspath(jproject); Set<String> resolved = new LinkedHashSet<String>(); for (int i = 0; i < unresolved.length; i++) { IRuntimeClasspathEntry entry = unresolved[i]; if (entry.getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) { IRuntimeClasspathEntry[] entries = JavaRuntime.resolveRuntimeClasspathEntry(entry, jproject, !includeTestScope); for (int j = 0; j < entries.length; j++) { if (!includeTestScope && JdtUtils.isTest(entries[j].getClasspathEntry())) { continue; } String location = entries[j].getLocation(); if (location != null) { // remove duplicate classpath resolved.add(location); } } } } return resolved.toArray(new String[resolved.size()]); }
JavaRuntime.computeUnresolvedRuntimeClasspath(proj), configuration);
private void createClasspathModel(ILaunchConfiguration configuration) throws CoreException { fModel= new ClasspathModel(); IRuntimeClasspathEntry[] entries= JavaRuntime.computeUnresolvedRuntimeClasspath(configuration); IRuntimeClasspathEntry entry; for (int i = 0; i < entries.length; i++) { entry= entries[i]; switch (entry.getClasspathProperty()) { case IRuntimeClasspathEntry.USER_CLASSES: fModel.addEntry(ClasspathModel.USER, entry); break; default: fModel.addEntry(ClasspathModel.BOOTSTRAP, entry); break; } } }
/** * Returns a collection with all dependencies of the Java project itself. * * @param adapter the confiugration adapter * @return a collection of dependencies * @throws CoreException on occasion */ public Collection<Dependency> getOriginalClasspathEntries(JettyLaunchConfigurationAdapter adapter) throws CoreException { @SuppressWarnings("unchecked") Collection<Dependency> result = (Collection<Dependency>) getCached("OriginalClasspathEntries", adapter); //$NON-NLS-1$ if (result != null) { return result; } IRuntimeClasspathEntry[] entries = JavaRuntime.computeUnresolvedRuntimeClasspath(adapter.getConfiguration()); entries = JavaRuntime.resolveRuntimeClasspath(entries, adapter.getConfiguration()); MavenDependencyInfoMap mavenScopeCollection = new MavenDependencyInfoMap(adapter, entries); Set<Dependency> scopedClasspathEntries = new LinkedHashSet<Dependency>(); for (IRuntimeClasspathEntry entry : entries) { scopedClasspathEntries.add(Dependency.create(mavenScopeCollection, entry)); } result = Collections.unmodifiableCollection(userClasses().match(scopedClasspathEntries)); putCached("OriginalClasspathEntries", adapter, result); //$NON-NLS-1$ return result; }
private void collectReferencedElements(IJavaProject project, HashSet result) throws CoreException { IRuntimeClasspathEntry[] unresolved = JavaRuntime.computeUnresolvedRuntimeClasspath(project); for (int i= 0; i < unresolved.length; i++) { IRuntimeClasspathEntry curr= unresolved[i]; if (curr.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) curr.getResource()))); } else { IRuntimeClasspathEntry[] entries= JavaRuntime.resolveRuntimeClasspathEntry(curr, project); for (int k = 0; k < entries.length; k++) { IRuntimeClasspathEntry entry= entries[k]; if (entry.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) entry.getResource()))); } else if (entry.getType() == IRuntimeClasspathEntry.ARCHIVE) { IClasspathEntry classpathEntry= entry.getClasspathEntry(); if (classpathEntry != null) { IPath containerPath= null; if (curr.getType() == IRuntimeClasspathEntry.CONTAINER) { containerPath= curr.getPath(); } result.add(new JavadocLinkRef(containerPath, classpathEntry, project)); } } } } } }
private void collectReferencedElements(IJavaProject project, HashSet<JavadocLinkRef> result) throws CoreException { IRuntimeClasspathEntry[] unresolved = JavaRuntime.computeUnresolvedRuntimeClasspath(project); for (int i= 0; i < unresolved.length; i++) { IRuntimeClasspathEntry curr= unresolved[i]; if (curr.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) curr.getResource()))); } else { IRuntimeClasspathEntry[] entries= JavaRuntime.resolveRuntimeClasspathEntry(curr, project); for (int k = 0; k < entries.length; k++) { IRuntimeClasspathEntry entry= entries[k]; if (entry.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) entry.getResource()))); } else if (entry.getType() == IRuntimeClasspathEntry.ARCHIVE) { IClasspathEntry classpathEntry= entry.getClasspathEntry(); if (classpathEntry != null) { IPath containerPath= null; if (curr.getType() == IRuntimeClasspathEntry.CONTAINER) { containerPath= curr.getPath(); } result.add(new JavadocLinkRef(containerPath, classpathEntry, project)); } } } } } }
private void collectReferencedElements(IJavaProject project, HashSet result) throws CoreException { IRuntimeClasspathEntry[] unresolved = JavaRuntime.computeUnresolvedRuntimeClasspath(project); for (int i= 0; i < unresolved.length; i++) { IRuntimeClasspathEntry curr= unresolved[i]; if (curr.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) curr.getResource()))); } else { IRuntimeClasspathEntry[] entries= JavaRuntime.resolveRuntimeClasspathEntry(curr, project); for (int k = 0; k < entries.length; k++) { IRuntimeClasspathEntry entry= entries[k]; if (entry.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) entry.getResource()))); } else if (entry.getType() == IRuntimeClasspathEntry.ARCHIVE) { IClasspathEntry classpathEntry= entry.getClasspathEntry(); if (classpathEntry != null) { IPath containerPath= null; if (curr.getType() == IRuntimeClasspathEntry.CONTAINER) { containerPath= curr.getPath(); } result.add(new JavadocLinkRef(containerPath, classpathEntry, project)); } } } } } }
private void collectReferencedElements(IJavaProject project, HashSet<JavadocLinkRef> result) throws CoreException { IRuntimeClasspathEntry[] unresolved = JavaRuntime.computeUnresolvedRuntimeClasspath(project); for (int i= 0; i < unresolved.length; i++) { IRuntimeClasspathEntry curr= unresolved[i]; if (curr.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) curr.getResource()))); } else { IRuntimeClasspathEntry[] entries= JavaRuntime.resolveRuntimeClasspathEntry(curr, project); for (int k = 0; k < entries.length; k++) { IRuntimeClasspathEntry entry= entries[k]; if (entry.getType() == IRuntimeClasspathEntry.PROJECT) { result.add(new JavadocLinkRef(JavaCore.create((IProject) entry.getResource()))); } else if (entry.getType() == IRuntimeClasspathEntry.ARCHIVE) { IClasspathEntry classpathEntry= entry.getClasspathEntry(); if (classpathEntry != null) { IPath containerPath= null; if (curr.getType() == IRuntimeClasspathEntry.CONTAINER) { containerPath= curr.getPath(); } result.add(new JavadocLinkRef(containerPath, classpathEntry, project)); } } } } } }
/** * Only does work if we are not currently using the default classpath * * @see org.eclipse.jface.action.Action#run() */ public void run() { try { ILaunchConfiguration config = fTab.getLaunchConfiguration(); if(!config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, false)) { ILaunchConfigurationWorkingCopy copy = null; if(config.isWorkingCopy()) { copy = (ILaunchConfigurationWorkingCopy) config; } else { copy = config.getWorkingCopy(); } copy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, true); getViewer().setEntries(JavaRuntime.computeUnresolvedRuntimeClasspath(copy)); } } catch (CoreException e) {return;} }
protected IRuntimeClasspathEntry[] getClasspath(ILaunchConfigurationWorkingCopy config) throws CoreException { RuntimeClasspathModel model = new RuntimeClasspathModel(config); config.setAttribute( IJavaLaunchConfigurationConstants.ATTR_CLASSPATH_PROVIDER, getClasspathProviderAttributeValue()); config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, Boolean.TRUE); IRuntimeClasspathEntry[] defaultEntries = JavaRuntime.computeUnresolvedRuntimeClasspath(config); for (IRuntimeClasspathEntry entry : defaultEntries) { switch (entry.getClasspathProperty()) { case IRuntimeClasspathEntry.USER_CLASSES: model.addEntry(RuntimeClasspathModel.USER, entry); break; default: break; } } addUserEntries(model); return getClasspathEntries(model); }