// Wrap the requirement as a hosted requirement if it comes
// from a fragment, since we will need to know the host. We
// also need to wrap if the requirement is a dynamic import,
// since that requirement will be shared with any other
// matching dynamic imports.
BundleRequirement r = wire.getRequirement();
if (!r.getRevision().equals(wire.getRequirerWiring().getRevision())
|| ((r.getDirectives().get(Constants.RESOLUTION_DIRECTIVE) != null)
&& r.getDirectives().get(Constants.RESOLUTION_DIRECTIVE).equals("dynamic")))
{
r = new HostedRequirement(
wire.getRequirerWiring().getRevision(),
(BundleRequirementImpl) r);
}
// Wrap the capability as a hosted capability if it comes
// from a fragment, since we will need to know the host.
BundleCapability c = wire.getCapability();
if (!c.getRevision().equals(wire.getProviderWiring().getRevision()))
{
c = new HostedCapability(
wire.getProviderWiring().getRevision(),
(BundleCapabilityImpl) c);
}
reqs.add(r);
caps.add(c);
}
// Since the revision is resolved, it could be dynamically importing,
// so check to see if there are candidates for any of its dynamic
// imports.
for (BundleRequirement req
: Util.getDynamicRequirements(revision.getWiring().getRequirements(null)))
{
// Get the candidates for the current requirement.
SortedSet<BundleCapability> candCaps =
allCandidates.getCandidates((BundleRequirementImpl) req);
// Optional requirements may not have any candidates.
if (candCaps == null)
{
continue;
}
BundleCapability cap = candCaps.iterator().next();
reqs.add(req);
caps.add(cap);
isDynamicImporting = true;
// Can only dynamically import one at a time, so break
// out of the loop after the first.
break;
}
}
else
{
for (BundleRequirement req : revision.getDeclaredRequirements(null))
{
String resolution = req.getDirectives().get(Constants.RESOLUTION_DIRECTIVE);
if ((resolution == null)
|| !resolution.equals(FelixConstants.RESOLUTION_DYNAMIC))
{
// Get the candidates for the current requirement.
SortedSet<BundleCapability> candCaps =
allCandidates.getCandidates((BundleRequirementImpl) req);
// Optional requirements may not have any candidates.
if (candCaps == null)
{
continue;
}
BundleCapability cap = candCaps.iterator().next();
reqs.add(req);
caps.add(cap);
}
}
}
// First, add all exported packages to the target revision's package space.
calculateExportedPackages(revision, allCandidates, revisionPkgMap);
Packages revisionPkgs = revisionPkgMap.get(revision);
// Second, add all imported packages to the target revision's package space.
for (int i = 0; i < reqs.size(); i++)
{
BundleRequirement req = reqs.get(i);
BundleCapability cap = caps.get(i);
calculateExportedPackages(cap.getRevision(), allCandidates, revisionPkgMap);
mergeCandidatePackages(
revision, req, cap, revisionPkgMap, allCandidates,
new HashMap<BundleRevision, List<BundleCapability>>());
}
// Third, have all candidates to calculate their package spaces.
for (int i = 0; i < caps.size(); i++)
{
calculatePackageSpaces(
caps.get(i).getRevision(), allCandidates, revisionPkgMap,
usesCycleMap, cycle);
}
// Fourth, if the target revision is unresolved or is dynamically importing,
// then add all the uses constraints implied by its imported and required
// packages to its package space.
// NOTE: We do not need to do this for resolved revisions because their
// package space is consistent by definition and these uses constraints
// are only needed to verify the consistency of a resolving revision. The
// only exception is if a resolved revision is dynamically importing, then
// we need to calculate its uses constraints again to make sure the new
// import is consistent with the existing package space.
if ((revision.getWiring() == null) || isDynamicImporting)
{
// Merge uses constraints from required capabilities.
for (int i = 0; i < reqs.size(); i++)
{
BundleRequirement req = reqs.get(i);
BundleCapability cap = caps.get(i);
// Ignore bundle/package requirements, since they are
// considered below.
if (!req.getNamespace().equals(BundleRevision.BUNDLE_NAMESPACE)
&& !req.getNamespace().equals(BundleRevision.PACKAGE_NAMESPACE))
{
List<BundleRequirement> blameReqs = new ArrayList<BundleRequirement>();
blameReqs.add(req);
mergeUses(