Exemple #1
0
 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();
 }