private void addSWTJars(List rtes) {
if (fgSWTEntries == null) {
fgSWTEntries = new ArrayList();
Bundle bundle = Platform.getBundle("org.eclipse.swt"); // $NON-NLS-1$
BundleDescription description =
Platform.getPlatformAdmin().getState(false).getBundle(bundle.getBundleId());
BundleDescription[] fragments = description.getFragments();
for (int i = 0; i < fragments.length; i++) {
Bundle fragmentBundle = Platform.getBundle(fragments[i].getName());
URL bundleURL;
try {
bundleURL = FileLocator.resolve(fragmentBundle.getEntry("/")); // $NON-NLS-1$
} catch (IOException e) {
AntLaunching.log(e);
continue;
}
String urlFileName = bundleURL.getFile();
if (urlFileName.startsWith("file:")) { // $NON-NLS-1$
try {
urlFileName = new URL(urlFileName).getFile();
if (urlFileName.endsWith("!/")) { // $NON-NLS-1$
urlFileName = urlFileName.substring(0, urlFileName.length() - 2);
}
} catch (MalformedURLException e) {
AntLaunching.log(e);
continue;
}
}
IPath fragmentPath = new Path(urlFileName);
if (fragmentPath.getFileExtension() != null) { // JAR file
fgSWTEntries.add(JavaRuntime.newArchiveRuntimeClasspathEntry(fragmentPath));
} else { // folder
File bundleFolder = fragmentPath.toFile();
if (!bundleFolder.isDirectory()) {
continue;
}
String[] names =
bundleFolder.list(
new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.endsWith(".jar"); // $NON-NLS-1$
}
});
for (int j = 0; j < names.length; j++) {
String jarName = names[j];
fgSWTEntries.add(
JavaRuntime.newArchiveRuntimeClasspathEntry(fragmentPath.append(jarName)));
}
}
}
}
rtes.addAll(fgSWTEntries);
}
// Copied from PDEClasspathContainer#resolveLibraryInFragments
protected static IPluginModelBase resolveLibraryInFragments(
IPluginModelBase model, String libraryName) {
BundleDescription desc = model.getBundleDescription();
if (desc != null) {
BundleDescription[] fragments = desc.getFragments();
for (int i = 0; i < fragments.length; i++) {
if (new File(fragments[i].getLocation(), libraryName).exists())
return PluginRegistry.findModel(fragments[i]);
}
}
return null;
}
/**
* Recursively adds the given {@link BundleDescription} and its dependents to the given {@link
* Set}
*
* @param desc the {@link BundleDescription} to compute dependencies for
* @param set the {@link Set} to collect results in
* @param includeOptional if optional dependencies should be included
* @param excludeFragments a collection of <b>fragment</b> bundle symbolic names to exclude from
* the dependency resolution
*/
private static void addBundleAndDependencies(
BundleDescription desc,
Set<String> set,
boolean includeOptional,
Set<String> excludeFragments) {
if (desc != null && set.add(desc.getSymbolicName())) {
BundleSpecification[] required = desc.getRequiredBundles();
for (int i = 0; i < required.length; i++) {
if (includeOptional || !required[i].isOptional()) {
addBundleAndDependencies(
(BundleDescription) required[i].getSupplier(),
set,
includeOptional,
excludeFragments);
}
}
ImportPackageSpecification[] importedPkgs = desc.getImportPackages();
for (int i = 0; i < importedPkgs.length; i++) {
ExportPackageDescription exporter =
(ExportPackageDescription) importedPkgs[i].getSupplier();
// Continue if the Imported Package is unresolved of the package is optional and don't want
// optional packages
if (exporter == null
|| (!includeOptional
&& Constants.RESOLUTION_OPTIONAL.equals(
importedPkgs[i].getDirective(Constants.RESOLUTION_DIRECTIVE)))) {
continue;
}
addBundleAndDependencies(exporter.getExporter(), set, includeOptional, excludeFragments);
}
BundleDescription[] fragments = desc.getFragments();
for (int i = 0; i < fragments.length; i++) {
if (!fragments[i].isResolved()) {
continue;
}
String id = fragments[i].getSymbolicName();
if (!excludeFragments.contains(id)) {
addBundleAndDependencies(fragments[i], set, includeOptional, excludeFragments);
}
}
HostSpecification host = desc.getHost();
if (host != null) {
addBundleAndDependencies(
(BundleDescription) host.getSupplier(), set, includeOptional, excludeFragments);
}
}
}
private Object[] getDependencies(BundleDescription desc) {
// use map to store dependencies so if Import-Package is supplied by same BundleDescription as
// supplier of Require-Bundle, it only shows up once
// Also, have to use BundleSpecficiation instead of BundleDescroption to show re-exported icon
// on re-exported Required-Bundles
// Have to use ImportPackageSpecification to determine if an import is optional and should be
// filtered.
HashMap<Object, Object> dependencies = new HashMap<Object, Object>();
BundleSpecification[] requiredBundles = desc.getRequiredBundles();
for (int i = 0; i < requiredBundles.length; i++) {
BaseDescription bd = requiredBundles[i].getSupplier();
if (bd != null) dependencies.put(bd, requiredBundles[i]);
else dependencies.put(requiredBundles[i], requiredBundles[i]);
}
ImportPackageSpecification[] importedPkgs = desc.getImportPackages();
for (int i = 0; i < importedPkgs.length; i++) {
BaseDescription bd = importedPkgs[i].getSupplier();
if (bd != null && bd instanceof ExportPackageDescription) {
BundleDescription exporter = ((ExportPackageDescription) bd).getExporter();
if (exporter != null) {
Object obj = dependencies.get(exporter);
if (obj == null) {
dependencies.put(exporter, importedPkgs[i]);
} else if (!Constants.RESOLUTION_OPTIONAL.equals(
importedPkgs[i].getDirective(Constants.RESOLUTION_DIRECTIVE))
&& obj instanceof ImportPackageSpecification
&& Constants.RESOLUTION_OPTIONAL.equals(
((ImportPackageSpecification) obj)
.getDirective(Constants.RESOLUTION_DIRECTIVE))) {
// if we have a non-optional Import-Package dependency on a bundle which we already
// depend on, check to make sure our
// current dependency is not optional. If it is, replace the optional dependency with
// the non-optional one
dependencies.put(exporter, importedPkgs[i]);
}
}
}
// ignore unresolved packages
}
// include fragments which are "linked" to this bundle
BundleDescription frags[] = desc.getFragments();
for (int i = 0; i < frags.length; i++) {
if (!frags[i].equals(fFragmentDescription)) dependencies.put(frags[i], frags[i]);
}
return dependencies.values().toArray();
}
