/** * Returns resolved entries for the given entry in the context of the given * Java project. If the entry is of kind * <code>VARIABLE</code> or <code>CONTAINER</code>, variable and container * resolvers are consulted. If the entry is of kind <code>PROJECT</code>, * and the associated Java project specifies non-default output locations, * the corresponding output locations are returned. Otherwise, the given * entry is returned. * <p> * If the given entry is a variable entry, and a resolver is not registered, * the entry itself is returned. If the given entry is a container, and a * resolver is not registered, resolved runtime classpath entries are calculated * from the associated container classpath entries, in the context of the * given project. * </p> * @param entry runtime classpath entry * @param project Java project context * @return resolved runtime classpath entry * @exception CoreException if unable to resolve * @see IRuntimeClasspathEntryResolver * @since 2.0 */ public static IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, IJavaProject project) throws CoreException { return resolveRuntimeClasspathEntry(entry, project, false); }
@Override public IRuntimeClasspathEntry[] resolveClasspath(IRuntimeClasspathEntry[] entries, ILaunchConfiguration configuration) throws CoreException { // use an ordered set to avoid duplicates Set<IRuntimeClasspathEntry> all = new LinkedHashSet<IRuntimeClasspathEntry>(entries.length); for (int i = 0; i < entries.length; i++) { IRuntimeClasspathEntry[] resolved =JavaRuntime.resolveRuntimeClasspathEntry(entries[i], configuration); for (int j = 0; j < resolved.length; j++) { all.add(resolved[j]); } } return all.toArray(new IRuntimeClasspathEntry[all.size()]); }
@Override public IRuntimeClasspathEntry[] resolveClasspath(IRuntimeClasspathEntry[] entries, ILaunchConfiguration configuration) throws CoreException { // use an ordered set to avoid duplicates Set<IRuntimeClasspathEntry> all = new LinkedHashSet<>(entries.length); for (int i = 0; i < entries.length; i++) { IRuntimeClasspathEntry[] resolved =JavaRuntime.resolveRuntimeClasspathEntry(entries[i], configuration); for (int j = 0; j < resolved.length; j++) { all.add(resolved[j]); } } return all.toArray(new IRuntimeClasspathEntry[all.size()]); }
@Override public IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, IJavaProject project, boolean excludeTestCode) throws CoreException { IRuntimeClasspathEntry2 entry2 = (IRuntimeClasspathEntry2)entry; IRuntimeClasspathEntry[] entries = entry2.getRuntimeClasspathEntries(excludeTestCode); List<IRuntimeClasspathEntry> resolved = new ArrayList<>(); for (int i = 0; i < entries.length; i++) { IRuntimeClasspathEntry[] temp = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], project, excludeTestCode); for (int j = 0; j < temp.length; j++) { resolved.add(temp[j]); } } return resolved.toArray(new IRuntimeClasspathEntry[resolved.size()]); }
@Override public IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry2 entry2 = (IRuntimeClasspathEntry2)entry; IRuntimeClasspathEntry[] entries = entry2.getRuntimeClasspathEntries(configuration); List<IRuntimeClasspathEntry> resolved = new ArrayList<IRuntimeClasspathEntry>(); for (int i = 0; i < entries.length; i++) { IRuntimeClasspathEntry[] temp = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], configuration); for (int j = 0; j < temp.length; j++) { resolved.add(temp[j]); } } return resolved.toArray(new IRuntimeClasspathEntry[resolved.size()]); } /* (non-Javadoc)
@Override public IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, IJavaProject project) throws CoreException { IRuntimeClasspathEntry2 entry2 = (IRuntimeClasspathEntry2)entry; IRuntimeClasspathEntry[] entries = entry2.getRuntimeClasspathEntries(null); List<IRuntimeClasspathEntry> resolved = new ArrayList<IRuntimeClasspathEntry>(); for (int i = 0; i < entries.length; i++) { IRuntimeClasspathEntry[] temp = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], project); for (int j = 0; j < temp.length; j++) { resolved.add(temp[j]); } } return resolved.toArray(new IRuntimeClasspathEntry[resolved.size()]); }
@Override public IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, ILaunchConfiguration configuration) throws CoreException { IRuntimeClasspathEntry2 entry2 = (IRuntimeClasspathEntry2)entry; IRuntimeClasspathEntry[] entries; entries = entry2.getRuntimeClasspathEntries(configuration); List<IRuntimeClasspathEntry> resolved = new ArrayList<>(); for (int i = 0; i < entries.length; i++) { IRuntimeClasspathEntry[] temp = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], configuration); for (int j = 0; j < temp.length; j++) { resolved.add(temp[j]); } } return resolved.toArray(new IRuntimeClasspathEntry[resolved.size()]); } /* (non-Javadoc)
private IRuntimeClasspathEntry[] resolveOther(IRuntimeClasspathEntry entry, ILaunchConfiguration configuration) throws CoreException { // The project dependency entries are represented with nonstandard IRuntimeClasspathEntry // and resolved by DefaultEntryResolver. The code below is a copy-paste of the // DefaultEntryResolver except that the inner resolveRuntimeClasspathEntry() method call is // replaced with a resolveClasspath(). This way we can intercept and update the project // entry resolution using the resolveProject() method. if (entry instanceof DefaultProjectClasspathEntry) { List<IRuntimeClasspathEntry> result = new ArrayList<>(); for (IRuntimeClasspathEntry e : ((IRuntimeClasspathEntry2) entry).getRuntimeClasspathEntries(configuration)) { Collections.addAll(result, resolveClasspath(new IRuntimeClasspathEntry[] { e }, configuration)); } return result.toArray(new IRuntimeClasspathEntry[result.size()]); } else { return JavaRuntime.resolveRuntimeClasspathEntry(entry, configuration); } }
@Override public IRuntimeClasspathEntry[] resolveClasspath(IRuntimeClasspathEntry[] entries, ILaunchConfiguration configuration) throws CoreException { Set<IRuntimeClasspathEntry> result = new LinkedHashSet<>(entries.length); for (IRuntimeClasspathEntry entry : entries) { switch (entry.getType()) { case IRuntimeClasspathEntry.OTHER: Collections.addAll(result, resolveOther(entry, configuration)); break; case IRuntimeClasspathEntry.PROJECT: Collections.addAll(result, resolveProject(entry, configuration)); break; default: Collections.addAll(result, JavaRuntime.resolveRuntimeClasspathEntry(entry, configuration)); break; } } return result.toArray(new IRuntimeClasspathEntry[result.size()]); }
public static IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry( IRuntimeClasspathEntry rtcp, IJavaProject jp) throws CoreException{ CachedRuntimeClasspathEntryResolver.setEnabled(true); IRuntimeClasspathEntry[] res = JavaRuntime.resolveRuntimeClasspathEntry(rtcp, jp); CachedRuntimeClasspathEntryResolver.setEnabled(false); return res; } }
public IRuntimeClasspathEntry[] getRuntimeClasspathEntries( ILaunchConfiguration configuration) throws CoreException { if(Plugin.CONTAINER_RJR_JETTY.equals(getVariableName())){ return RunJettyRunLaunchConfigurationUtil.loadPackage(configuration, IJettyPackageProvider.TYPE_JETTY_BUNDLE); }else if(Plugin.CONTAINER_RJR_JETTY_JNDI.equals(getVariableName())){ return RunJettyRunLaunchConfigurationUtil.loadPackage(configuration, IJettyPackageProvider.TYPE_UTIL); }else return JavaRuntime.resolveRuntimeClasspathEntry(this, configuration); }
/** * Computes the class path entries which are on the user class path and are * explicitely put on the boot class path. * * @param project * the project to compute the classpath for * @return the computed classpath. May be empty, but not null. * @throws CoreException * if the project's class path cannot be computed */ public static String[] computeUserAndBootClasspath(final IJavaProject project) throws CoreException { final IRuntimeClasspathEntry[] unresolved= JavaRuntime.computeUnresolvedRuntimeClasspath(project); final List resolved= new ArrayList(unresolved.length); for (int index= 0; index < unresolved.length; index++) { final IRuntimeClasspathEntry entry= unresolved[index]; final int property= entry.getClasspathProperty(); if (property == IRuntimeClasspathEntry.USER_CLASSES || property == IRuntimeClasspathEntry.BOOTSTRAP_CLASSES) { final IRuntimeClasspathEntry[] entries= JavaRuntime.resolveRuntimeClasspathEntry(entry, project); for (int offset= 0; offset < entries.length; offset++) { final String location= entries[offset].getLocation(); if (location != null) resolved.add(location); } } } return (String[]) resolved.toArray(new String[resolved.size()]); }
/** * Computes the default application classpath entries for the given * project. * * @param jproject The project to compute the classpath for * @return The computed classpath. May be empty, but not null. * @throws CoreException if unable to compute the default classpath */ public static String[] computeDefaultRuntimeClassPath(IJavaProject jproject) throws CoreException { IRuntimeClasspathEntry[] unresolved = computeUnresolvedRuntimeClasspath(jproject); // 1. remove bootpath entries // 2. resolve & translate to local file system paths List<String> resolved = new ArrayList<String>(unresolved.length); for (int i = 0; i < unresolved.length; i++) { IRuntimeClasspathEntry entry = unresolved[i]; if (entry.getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) { IRuntimeClasspathEntry[] entries = resolveRuntimeClasspathEntry(entry, jproject); for (int j = 0; j < entries.length; j++) { String location = entries[j].getLocation(); if (location != null) { resolved.add(location); } } } } return resolved.toArray(new String[resolved.size()]); }
public IRuntimeClasspathEntry[] resolveClasspath(IRuntimeClasspathEntry[] entries, ILaunchConfiguration configuration) throws CoreException { List all = new ArrayList(entries.length); for (int i = 0; i < entries.length; i++) { if (entries[i].getType() == IRuntimeClasspathEntry.PROJECT) { // a project resolves to itself for source lookup (rather than // the class file output locations) all.add(entries[i]); // also add non-JRE libraries IResource resource = entries[i].getResource(); if (resource instanceof IProject) { addBinaryPackageFragmentRoots(JavaCore.create((IProject) resource), all); } } else { IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], configuration); for (int j = 0; j < resolved.length; j++) { all.add(resolved[j]); } } } return (IRuntimeClasspathEntry[]) all.toArray(new IRuntimeClasspathEntry[all.size()]); }
/** * Computes the default application classpath entries for the given * project. * * @param jproject The project to compute the classpath for * @return The computed classpath. May be empty, but not null. * @throws CoreException if unable to compute the default classpath */ public static String[] computeDefaultRuntimeClassPath(IJavaProject jproject) throws CoreException { IRuntimeClasspathEntry[] unresolved = computeUnresolvedRuntimeClasspath(jproject); // 1. remove bootpath entries // 2. resolve & translate to local file system paths List<String> resolved = new ArrayList<>(unresolved.length); for (int i = 0; i < unresolved.length; i++) { IRuntimeClasspathEntry entry = unresolved[i]; if (entry.getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) { IRuntimeClasspathEntry[] entries = resolveRuntimeClasspathEntry(entry, jproject); for (int j = 0; j < entries.length; j++) { String location = entries[j].getLocation(); if (location != null) { resolved.add(location); } } } } return resolved.toArray(new String[resolved.size()]); }
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()]); }
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<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)); } } } } } }