public void computeImports() throws CoreException {
// some existing imports may valid and can be preserved
Vector preservedImports = new Vector(fImports.size());
// new imports
ArrayList newImports = new ArrayList();
IPluginModelBase model = null;
for (int i = 0; i < fPlugins.size(); i++) {
IFeaturePlugin fp = (IFeaturePlugin) fPlugins.get(i);
ModelEntry entry = PluginRegistry.findEntry(fp.getId());
if (entry == null) continue;
IPluginModelBase[] models = entry.getActiveModels();
for (int j = 0; j < models.length; j++) {
IPluginModelBase m = models[j];
if (fp.getVersion().equals(m.getPluginBase().getVersion())
|| fp.getVersion().equals("0.0.0")) // $NON-NLS-1$
model = m;
}
if (model != null) {
addPluginImports(preservedImports, newImports, model.getPluginBase());
if (model.isFragmentModel()) {
BundleDescription desc = model.getBundleDescription();
if (desc == null) continue;
HostSpecification hostSpec = desc.getHost();
String id = hostSpec.getName();
String version = null;
int match = IMatchRules.NONE;
VersionRange versionRange = hostSpec.getVersionRange();
if (!(versionRange == null || VersionRange.emptyRange.equals(versionRange))) {
version =
versionRange.getMinimum() != null ? versionRange.getMinimum().toString() : null;
match = PluginBase.getMatchRule(versionRange);
}
addNewDependency(id, version, match, preservedImports, newImports);
}
}
}
// preserve imports of features
for (int i = 0; i < fImports.size(); i++) {
IFeatureImport iimport = (IFeatureImport) fImports.get(i);
if (iimport.getType() == IFeatureImport.FEATURE) preservedImports.add(iimport);
}
// removed = old - preserved
Vector removedImports = ((Vector) fImports.clone());
removedImports.removeAll(preservedImports);
// perform remove
fImports = preservedImports;
if (removedImports.size() > 0) {
fireStructureChanged(
(IFeatureImport[]) removedImports.toArray(new IFeatureImport[removedImports.size()]),
IModelChangedEvent.REMOVE);
}
// perform add
if (newImports.size() > 0) {
fImports.addAll(newImports);
fireStructureChanged(
(IFeatureImport[]) newImports.toArray(new IFeatureImport[newImports.size()]),
IModelChangedEvent.INSERT);
}
}
/**
* 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);
}
}
}
protected Object[] findCallees(IPluginModelBase model) {
BundleDescription desc = model.getBundleDescription();
if (desc == null) return new Object[0];
fFragmentDescription = null;
HostSpecification spec = desc.getHost();
if (spec != null) {
fFragmentDescription = desc;
Object[] fragmentDependencies = getDependencies(desc);
BaseDescription host = spec.getSupplier();
if (host instanceof BundleDescription) {
BundleDescription hostDesc = (BundleDescription) host;
// check to see if the host is already included as a dependency. If so, we don't need to
// include the host manually.
for (int i = 0; i < fragmentDependencies.length; i++) {
BundleDescription dependency = null;
if (fragmentDependencies[i] instanceof BundleSpecification)
dependency = ((BundleSpecification) fragmentDependencies[i]).getBundle();
else if (fragmentDependencies[i] instanceof ImportPackageSpecification) {
ExportPackageDescription epd =
(ExportPackageDescription)
((ImportPackageSpecification) fragmentDependencies[i]).getSupplier();
if (epd != null) dependency = epd.getSupplier();
}
if (dependency != null && dependency.equals(hostDesc)) return fragmentDependencies;
}
// host not included as dependency, include it manually.
Object[] result = new Object[fragmentDependencies.length + 1];
result[0] = hostDesc;
System.arraycopy(fragmentDependencies, 0, result, 1, fragmentDependencies.length);
return result;
}
return fragmentDependencies;
}
return getDependencies(desc);
}
public static void handleAddRequired(IProductPlugin[] plugins, boolean includeOptional) {
if (plugins.length == 0) return;
ArrayList<BundleDescription> list = new ArrayList<BundleDescription>(plugins.length);
for (int i = 0; i < plugins.length; i++) {
list.add(TargetPlatformHelper.getState().getBundle(plugins[i].getId(), null));
}
DependencyCalculator calculator = new DependencyCalculator(includeOptional);
calculator.findDependencies(list.toArray());
BundleDescription[] bundles = TargetPlatformHelper.getState().getBundles();
for (int i = 0; i < bundles.length; i++) {
HostSpecification host = bundles[i].getHost();
if (host != null
&& !("org.eclipse.ui.workbench.compatibility"
.equals(bundles[i].getSymbolicName())) // $NON-NLS-1$
&& calculator.containsPluginId(host.getName())) {
calculator.findDependency(bundles[i]);
}
}
Collection<?> dependencies = calculator.getBundleIDs();
IProduct product = plugins[0].getProduct();
IProductModelFactory factory = product.getModel().getFactory();
IProductPlugin[] requiredPlugins = new IProductPlugin[dependencies.size()];
int i = 0;
Iterator<?> iter = dependencies.iterator();
while (iter.hasNext()) {
String id = iter.next().toString();
IProductPlugin plugin = factory.createPlugin();
plugin.setId(id);
requiredPlugins[i++] = plugin;
}
product.addPlugins(requiredPlugins);
}