package org.eclipse.jdt.launching;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.core.IJavaProject;
public class StandardClasspathProvider implements IRuntimeClasspathProvider {
@Override
public IRuntimeClasspathEntry[] computeUnresolvedClasspath(ILaunchConfiguration configuration) throws CoreException {
boolean useDefault = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, true);
boolean isModular = JavaRuntime.isModularConfiguration(configuration);
boolean excludeTestCode = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_EXCLUDE_TEST_CODE, false);
if (useDefault) {
IJavaProject proj = JavaRuntime.getJavaProject(configuration);
IRuntimeClasspathEntry jreEntry = JavaRuntime.computeJREEntry(configuration);
if (proj == null) {
if (jreEntry == null) {
return new IRuntimeClasspathEntry[0];
}
return new IRuntimeClasspathEntry[]{jreEntry};
}
IRuntimeClasspathEntry[] entries = null;
if (isModular) {
entries = JavaRuntime.computeUnresolvedRuntimeDependencies(proj, excludeTestCode);
} else {
entries = JavaRuntime.computeUnresolvedRuntimeClasspath(proj, excludeTestCode);
}
IRuntimeClasspathEntry projEntry = isModular ? JavaRuntime.computeModularJREEntry(proj) : JavaRuntime.computeJREEntry(proj);
if (jreEntry != null && projEntry != null) {
if (!jreEntry.equals(projEntry)) {
for (int i = 0; i < entries.length; i++) {
IRuntimeClasspathEntry entry = entries[i];
if (entry.equals(projEntry)) {
entries[i] = jreEntry;
return entries;
}
}
}
}
return entries;
}
if (isModular) {
IRuntimeClasspathEntry[] runtimeModulePaths = recoverRuntimePath(configuration, IJavaLaunchConfigurationConstants.ATTR_MODULEPATH);
IRuntimeClasspathEntry[] runtimeClasspaths = recoverRuntimePath(configuration, IJavaLaunchConfigurationConstants.ATTR_CLASSPATH);
IRuntimeClasspathEntry[] result = Arrays.copyOf(runtimeModulePaths, runtimeModulePaths.length + runtimeClasspaths.length);
System.arraycopy(runtimeClasspaths, 0, result, runtimeModulePaths.length, runtimeClasspaths.length);
return result;
}
return recoverRuntimePath(configuration, IJavaLaunchConfigurationConstants.ATTR_CLASSPATH);
}
@Override
public IRuntimeClasspathEntry[] resolveClasspath(IRuntimeClasspathEntry[] entries, ILaunchConfiguration configuration) throws CoreException {
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()]);
}
protected IRuntimeClasspathEntry[] recoverRuntimePath(ILaunchConfiguration configuration, String attribute) throws CoreException {
List<String> entries = configuration.getAttribute(attribute, Collections.EMPTY_LIST);
IRuntimeClasspathEntry[] rtes = new IRuntimeClasspathEntry[entries.size()];
Iterator<String> iter = entries.iterator();
int i = 0;
while (iter.hasNext()) {
rtes[i] = JavaRuntime.newRuntimeClasspathEntry(iter.next());
i++;
}
return rtes;
}
}