You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@felix.apache.org by ri...@apache.org on 2010/01/06 22:35:28 UTC
svn commit: r896679 - in
/felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver:
RequirementImpl.java felix/FelixResolver.java felix/FelixResolverImpl.java
proto3/Proto3Resolver.java
Author: rickhall
Date: Wed Jan 6 21:35:18 2010
New Revision: 896679
URL: http://svn.apache.org/viewvc?rev=896679&view=rev
Log:
Get legacy resolver working again.
Modified:
felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/RequirementImpl.java
felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolver.java
felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolverImpl.java
felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/proto3/Proto3Resolver.java
Modified: felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/RequirementImpl.java
URL: http://svn.apache.org/viewvc/felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/RequirementImpl.java?rev=896679&r1=896678&r2=896679&view=diff
==============================================================================
--- felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/RequirementImpl.java (original)
+++ felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/RequirementImpl.java Wed Jan 6 21:35:18 2010
@@ -90,29 +90,32 @@
m_attrs.put(n, new Attribute(n, v, false));
}
- String targetName = null;
- if (m_namespace.equals(Capability.MODULE_NAMESPACE))
+ if (m_name == null)
{
- if (n.equals(Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE))
+ String targetName = null;
+ if (m_namespace.equals(Capability.MODULE_NAMESPACE))
{
- targetName = v;
+ if (n.equals(Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE))
+ {
+ targetName = v;
+ }
}
- }
- else if (m_namespace.equals(Capability.PACKAGE_NAMESPACE))
- {
- if (n.equals(Capability.PACKAGE_ATTR))
+ else if (m_namespace.equals(Capability.PACKAGE_NAMESPACE))
{
- targetName = v;
+ if (n.equals(Capability.PACKAGE_ATTR))
+ {
+ targetName = v;
+ }
}
- }
- else if (m_namespace.equals(Capability.HOST_NAMESPACE))
- {
- if (n.equals(Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE))
+ else if (m_namespace.equals(Capability.HOST_NAMESPACE))
{
- targetName = v;
+ if (n.equals(Constants.BUNDLE_SYMBOLICNAME_ATTRIBUTE))
+ {
+ targetName = v;
+ }
}
+ m_name = targetName;
}
- m_name = targetName;
}
m_filter = null;
getFilter();
Modified: felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolver.java
URL: http://svn.apache.org/viewvc/felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolver.java?rev=896679&r1=896678&r2=896679&view=diff
==============================================================================
--- felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolver.java (original)
+++ felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolver.java Wed Jan 6 21:35:18 2010
@@ -58,12 +58,15 @@
// Second, index module's capabilities.
//
- List<Capability> eps = module.getCapabilities();
+ List<Capability> caps = module.getCapabilities();
// Add exports to unresolved package map.
- for (int i = 0; (eps != null) && (i < eps.size()); i++)
+ for (int i = 0; (caps != null) && (i < caps.size()); i++)
{
- indexPackageCapability(eps.get(i));
+ if (caps.get(i).getNamespace().equals(Capability.PACKAGE_NAMESPACE))
+ {
+ indexPackageCapability(caps.get(i));
+ }
}
}
@@ -155,17 +158,49 @@
public List<Capability> getUnresolvedCandidates(Requirement req)
{
+ // Get all matching unresolved capabilities.
List<Capability> matches = new ArrayList<Capability>();
- List<Capability> candidates = m_unresolvedPkgIndex.get(((RequirementImpl) req).getName());
- for (int candIdx = 0; (candidates != null) && (candIdx < candidates.size()); candIdx++)
+ if (req.getNamespace().equals(Capability.PACKAGE_NAMESPACE))
{
- Capability export = candidates.get(candIdx);
- if (((RequirementImpl) req).isSatistfiedBy(export))
+ List<Capability> candidates = m_unresolvedPkgIndex.get(((RequirementImpl) req).getName());
+ for (int candIdx = 0; (candidates != null) && (candIdx < candidates.size()); candIdx++)
{
- matches.add(export);
+ // If compatible and it is not currently resolved, then add
+ // the unresolved candidate to the list.
+ if (((RequirementImpl) req).isSatistfiedBy(candidates.get(candIdx)))
+ {
+ matches.add(candidates.get(candIdx));
+ }
+ }
+ }
+ else
+ {
+ for (int modIdx = 0; modIdx < m_moduleList.size(); modIdx++)
+ {
+ // Get the module's export package for the target package.
+ Capability cap = getSatisfyingCapability(m_moduleList.get(modIdx), req);
+ // If compatible and it is not currently resolved, then add
+ // the unresolved candidate to the list.
+ if ((cap != null) && !m_moduleList.get(modIdx).isResolved())
+ {
+ matches.add(cap);
+ }
}
}
return matches;
}
}
+
+ private static Capability getSatisfyingCapability(Module module, Requirement req)
+ {
+ List<Capability> caps = module.getCapabilities();
+ for (Capability cap : caps)
+ {
+ if (((RequirementImpl) req).isSatistfiedBy(cap))
+ {
+ return cap;
+ }
+ }
+ return null;
+ }
}
\ No newline at end of file
Modified: felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolverImpl.java
URL: http://svn.apache.org/viewvc/felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolverImpl.java?rev=896679&r1=896678&r2=896679&view=diff
==============================================================================
--- felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolverImpl.java (original)
+++ felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/felix/FelixResolverImpl.java Wed Jan 6 21:35:18 2010
@@ -30,6 +30,9 @@
import org.apache.felix.resolver.Wire;
import org.apache.felix.resolver.cs.Capability;
import org.apache.felix.resolver.cs.Requirement;
+import org.apache.felix.resolver.manifestparser.Constants;
+import org.apache.felix.resolver.manifestparser.FelixRequirement;
+import org.apache.felix.resolver.manifestparser.R4Directive;
public class FelixResolverImpl
{
@@ -119,8 +122,9 @@
// package maps. The "resolved" candidates have higher priority
// than "unresolved" ones, so put the "resolved" candidates
// at the front of the list of candidates.
- List<Capability> candidates = state.getResolvedCandidates(reqs.get(reqIdx));
+ List candidates = state.getResolvedCandidates(reqs.get(reqIdx));
candidates.addAll(state.getUnresolvedCandidates(reqs.get(reqIdx)));
+
// If we have candidates, then we need to recursively populate
// the resolver map with each of them.
ResolveException rethrow = null;
@@ -234,7 +238,8 @@
// If the requirement is not optional, then add the module
// to a list which will be removed after removing the current
// invalid module.
- if ((module != invalidModule) && !invalidList.contains(module))
+ if (!cs.m_requirement.isOptional() && (module != invalidModule)
+ && !invalidList.contains(module))
{
invalidList.add(module);
}
@@ -626,16 +631,37 @@
//System.out.println("calculateModulePackages("+module+")");
Map importedPackages = calculateImportedPackages(module, candidatesMap);
Map exportedPackages = calculateExportedPackages(module);
+ Map requiredPackages = calculateRequiredPackages(module, candidatesMap);
+
+ // Merge exported packages into required packages. If a package is both
+ // exported and required, then append the exported package to the end of
+ // the require packages; otherwise just add it to the package map.
+ for (Iterator i = exportedPackages.entrySet().iterator(); i.hasNext(); )
+ {
+ Map.Entry entry = (Map.Entry) i.next();
+ ResolvedPackage rpReq = (ResolvedPackage) requiredPackages.get(entry.getKey());
+ if (rpReq != null)
+ {
+ // Merge exported and required packages, avoiding duplicate
+ // packages and maintaining ordering.
+ ResolvedPackage rpExport = (ResolvedPackage) entry.getValue();
+ rpReq.merge(rpExport);
+ }
+ else
+ {
+ requiredPackages.put(entry.getKey(), entry.getValue());
+ }
+ }
- // Merge imported packages into exported packages. Imports overwrite
+ // Merge imported packages into required packages. Imports overwrite
// any required and/or exported package.
for (Iterator i = importedPackages.entrySet().iterator(); i.hasNext(); )
{
Map.Entry entry = (Map.Entry) i.next();
- exportedPackages.put(entry.getKey(), entry.getValue());
+ requiredPackages.put(entry.getKey(), entry.getValue());
}
- return exportedPackages;
+ return requiredPackages;
}
private static Map calculateImportedPackages(Module targetModule, Map candidatesMap)
@@ -666,11 +692,14 @@
CandidateSet cs = (CandidateSet) candSetList.get(candSetIdx);
Capability candCap = (Capability) cs.m_candidates.get(cs.m_idx);
- String pkgName = (String) candCap.getAttribute(Capability.PACKAGE_ATTR).getValue();
+ if (candCap.getNamespace().equals(Capability.PACKAGE_NAMESPACE))
+ {
+ String pkgName = (String) candCap.getAttribute(Capability.PACKAGE_ATTR).getValue();
- ResolvedPackage rp = new ResolvedPackage(pkgName, cs);
- rp.m_capList.add(candCap);
- pkgMap.put(rp.m_name, rp);
+ ResolvedPackage rp = new ResolvedPackage(pkgName, cs);
+ rp.m_capList.add(candCap);
+ pkgMap.put(rp.m_name, rp);
+ }
}
return pkgMap;
@@ -688,13 +717,16 @@
List<Wire> wires = targetModule.getWires();
for (int wireIdx = 0; (wires != null) && (wireIdx < wires.size()); wireIdx++)
{
- Wire wire = wires.get(wireIdx);
- String pkgName = (String)
- wire.getCapability().getAttribute(Capability.PACKAGE_ATTR).getValue();
- ResolvedPackage rp = (ResolvedPackage) pkgMap.get(pkgName);
- rp = (rp == null) ? new ResolvedPackage(pkgName, null) : rp;
- rp.m_capList.add(wire.getCapability());
- pkgMap.put(rp.m_name, rp);
+ if (wires.get(wireIdx).getCapability().getNamespace().equals(Capability.PACKAGE_NAMESPACE))
+ {
+ Wire wire = wires.get(wireIdx);
+ String pkgName = (String)
+ wire.getCapability().getAttribute(Capability.PACKAGE_ATTR).getValue();
+ ResolvedPackage rp = (ResolvedPackage) pkgMap.get(pkgName);
+ rp = (rp == null) ? new ResolvedPackage(pkgName, null) : rp;
+ rp.m_capList.add(wire.getCapability());
+ pkgMap.put(rp.m_name, rp);
+ }
}
return pkgMap;
@@ -710,17 +742,380 @@
List<Capability> caps = targetModule.getCapabilities();
for (int capIdx = 0; (caps != null) && (capIdx < caps.size()); capIdx++)
{
- String pkgName = (String)
- caps.get(capIdx).getAttribute(Capability.PACKAGE_ATTR).getValue();
- ResolvedPackage rp = (ResolvedPackage) pkgMap.get(pkgName);
- rp = (rp == null) ? new ResolvedPackage(pkgName, null) : rp;
- rp.m_capList.add(caps.get(capIdx));
- pkgMap.put(rp.m_name, rp);
+ if (caps.get(capIdx).getNamespace().equals(Capability.PACKAGE_NAMESPACE))
+ {
+ String pkgName = (String)
+ caps.get(capIdx).getAttribute(Capability.PACKAGE_ATTR).getValue();
+ ResolvedPackage rp = (ResolvedPackage) pkgMap.get(pkgName);
+ rp = (rp == null) ? new ResolvedPackage(pkgName, null) : rp;
+ rp.m_capList.add(caps.get(capIdx));
+ pkgMap.put(rp.m_name, rp);
+ }
+ }
+
+ return pkgMap;
+ }
+
+ private static Map calculateRequiredPackages(Module targetModule, Map candidatesMap)
+ {
+ return (candidatesMap.get(targetModule) == null)
+ ? calculateRequiredPackagesResolved(targetModule)
+ : calculateRequiredPackagesUnresolved(targetModule, candidatesMap);
+ }
+
+ private static Map calculateRequiredPackagesUnresolved(Module targetModule, Map candidatesMap)
+ {
+//System.out.println("calculateRequiredPackagesUnresolved("+targetModule+")");
+ Map pkgMap = new HashMap();
+
+ // Loop through target module's candidate list for candidates
+ // for its module dependencies and merge re-exported packages.
+ List candSetList = (List) candidatesMap.get(targetModule);
+ for (int candSetIdx = 0;
+ (candSetList != null) && (candSetIdx < candSetList.size());
+ candSetIdx++)
+ {
+ CandidateSet cs = (CandidateSet) candSetList.get(candSetIdx);
+ Capability candCap = (Capability) cs.m_candidates.get(cs.m_idx);
+
+ // If the capabaility is a module dependency, then flatten it to packages.
+ if (candCap.getNamespace().equals(Capability.MODULE_NAMESPACE))
+ {
+ // Calculate transitively required packages.
+ Map cycleMap = new HashMap();
+ cycleMap.put(targetModule, targetModule);
+ Map requireMap =
+ calculateExportedAndReexportedPackages(
+ candCap, candidatesMap, cycleMap);
+
+ // Take the flattened required package map for the current
+ // module dependency and merge it into the existing map
+ // of required packages.
+ for (Iterator reqIter = requireMap.entrySet().iterator(); reqIter.hasNext(); )
+ {
+ Map.Entry entry = (Map.Entry) reqIter.next();
+ ResolvedPackage rp = (ResolvedPackage) pkgMap.get(entry.getKey());
+ if (rp != null)
+ {
+ // Merge required packages, avoiding duplicate
+ // packages and maintaining ordering.
+ ResolvedPackage rpReq = (ResolvedPackage) entry.getValue();
+ rp.merge(rpReq);
+ }
+ else
+ {
+ pkgMap.put(entry.getKey(), entry.getValue());
+ }
+ }
+ }
+ }
+
+ return pkgMap;
+ }
+
+ private static Map calculateRequiredPackagesResolved(Module targetModule)
+ {
+//System.out.println("calculateRequiredPackagesResolved("+targetModule+")");
+ Map pkgMap = new HashMap();
+
+ // Loop through target module's wires for module dependencies
+ // and merge re-exported packages.
+ List<Wire> wires = targetModule.getWires();
+ for (int i = 0; (wires != null) && (i < wires.size()); i++)
+ {
+ // If the wire is a module dependency, then flatten it to packages.
+ if (wires.get(i).getCapability().getNamespace().equals(Capability.MODULE_NAMESPACE))
+ {
+ // Calculate transitively required packages.
+ // We can call calculateExportedAndReexportedPackagesResolved()
+ // directly, since we know all dependencies have to be resolved
+ // because this module itself is resolved.
+ Map cycleMap = new HashMap();
+ cycleMap.put(targetModule, targetModule);
+ Map requireMap =
+ calculateExportedAndReexportedPackagesResolved(
+ wires.get(i).getExporter(), cycleMap);
+
+ // Take the flattened required package map for the current
+ // module dependency and merge it into the existing map
+ // of required packages.
+ for (Iterator reqIter = requireMap.entrySet().iterator(); reqIter.hasNext(); )
+ {
+ Map.Entry entry = (Map.Entry) reqIter.next();
+ ResolvedPackage rp = (ResolvedPackage) pkgMap.get(entry.getKey());
+ if (rp != null)
+ {
+ // Merge required packages, avoiding duplicate
+ // packages and maintaining ordering.
+ ResolvedPackage rpReq = (ResolvedPackage) entry.getValue();
+ rp.merge(rpReq);
+ }
+ else
+ {
+ pkgMap.put(entry.getKey(), entry.getValue());
+ }
+ }
+ }
+ }
+
+ return pkgMap;
+ }
+
+ private static Map calculateExportedAndReexportedPackages(
+ Capability capTarget, Map candidatesMap, Map cycleMap)
+ {
+ return (candidatesMap.get(capTarget.getModule()) == null)
+ ? calculateExportedAndReexportedPackagesResolved(capTarget.getModule(), cycleMap)
+ : calculateExportedAndReexportedPackagesUnresolved(capTarget, candidatesMap, cycleMap);
+ }
+
+ private static Map calculateExportedAndReexportedPackagesUnresolved(
+ Capability capTarget, Map candidatesMap, Map cycleMap)
+ {
+//System.out.println("calculateExportedAndReexportedPackagesUnresolved("+psTarget.m_module+")");
+ Map pkgMap = new HashMap();
+
+ if (cycleMap.get(capTarget.getModule()) != null)
+ {
+ return pkgMap;
+ }
+
+ cycleMap.put(capTarget.getModule(), capTarget.getModule());
+
+ // Loop through all current candidates for target module's dependencies
+ // and calculate the module's complete set of required packages (and
+ // their associated packages) and the complete set of required
+ // packages to be re-exported.
+ Map allRequiredMap = new HashMap();
+ Map reexportedPkgMap = new HashMap();
+ List candSetList = (List) candidatesMap.get(capTarget.getModule());
+ for (int candSetIdx = 0; candSetIdx < candSetList.size(); candSetIdx++)
+ {
+ CandidateSet cs = (CandidateSet) candSetList.get(candSetIdx);
+ Capability candCap = (Capability) cs.m_candidates.get(cs.m_idx);
+
+ // If the candidate is resolving a module dependency, then
+ // flatten the required packages if they are re-exported.
+ if (candCap.getNamespace().equals(Capability.MODULE_NAMESPACE))
+ {
+ // Determine if required packages are re-exported.
+ boolean reexport = false;
+ R4Directive[] dirs = ((FelixRequirement) cs.m_requirement).getDirectives();
+ for (int dirIdx = 0;
+ !reexport && (dirs != null) && (dirIdx < dirs.length); dirIdx++)
+ {
+ if (dirs[dirIdx].getName().equals(Constants.VISIBILITY_DIRECTIVE)
+ && dirs[dirIdx].getValue().equals(Constants.VISIBILITY_REEXPORT))
+ {
+ reexport = true;
+ }
+ }
+
+ // Recursively calculate the required packages for the
+ // current candidate.
+ Map requiredMap =
+ calculateExportedAndReexportedPackages(candCap, candidatesMap, cycleMap);
+
+ // Merge the candidate's exported and required packages
+ // into the complete set of required packages.
+ for (Iterator reqIter = requiredMap.entrySet().iterator(); reqIter.hasNext(); )
+ {
+ Map.Entry entry = (Map.Entry) reqIter.next();
+ String pkgName = (String) entry.getKey();
+
+ // Merge the current set of required packages into
+ // the overall complete set of required packages.
+ // We calculate all the required packages, because
+ // despite the fact that some packages will be required
+ // "privately" and some will be required "reexport", any
+ // re-exported packages will ultimately need to
+ // be combined with privately required packages,
+ // if the required packages overlap. This is one of the
+ // bad things about require-bundle behavior, it does not
+ // necessarily obey the visibility rules declared in the
+ // dependency.
+ ResolvedPackage rp = (ResolvedPackage) allRequiredMap.get(pkgName);
+ if (rp != null)
+ {
+ // Create the union of all packages.
+ ResolvedPackage rpReq = (ResolvedPackage) entry.getValue();
+ rp.merge(rpReq);
+ }
+ else
+ {
+ // Add package to required map.
+ allRequiredMap.put(pkgName, entry.getValue());
+ }
+
+ // Keep track of all required packages to be re-exported.
+ // All re-exported packages will need to be merged into the
+ // target module's package map and become part of its overall
+ // export signature.
+ if (reexport)
+ {
+ reexportedPkgMap.put(pkgName, pkgName);
+ }
+ }
+ }
+ }
+
+ // For the target module we have now calculated its entire set
+ // of required packages and their associated packages in
+ // allRequiredMap and have calculated all packages to be re-exported
+ // in reexportedPkgMap. Add all re-exported required packages to the
+ // target module's package map since they will be part of its export
+ // signature.
+ for (Iterator iter = reexportedPkgMap.entrySet().iterator(); iter.hasNext(); )
+ {
+ String pkgName = (String) ((Map.Entry) iter.next()).getKey();
+ pkgMap.put(pkgName, allRequiredMap.get(pkgName));
+ }
+
+ // Now loop through the target module's export package capabilities and add
+ // the target module's export capability as a source for any exported packages.
+ List<Capability> candCaps = capTarget.getModule().getCapabilities();
+ for (int capIdx = 0; (candCaps != null) && (capIdx < candCaps.size()); capIdx++)
+ {
+ if (candCaps.get(capIdx).getNamespace().equals(Capability.PACKAGE_NAMESPACE))
+ {
+ String pkgName = (String)
+ candCaps.get(capIdx).getAttribute(Capability.PACKAGE_ATTR).getValue();
+ ResolvedPackage rp = (ResolvedPackage) pkgMap.get(pkgName);
+ rp = (rp == null) ? new ResolvedPackage(pkgName, null) : rp;
+ rp.m_capList.add(candCaps.get(capIdx));
+ pkgMap.put(rp.m_name, rp);
+ }
+ }
+
+ return pkgMap;
+ }
+
+ private static Map calculateExportedAndReexportedPackagesResolved(
+ Module targetModule, Map cycleMap)
+ {
+//System.out.println("calculateExportedAndRequiredPackagesResolved("+targetModule+")");
+ Map pkgMap = new HashMap();
+
+ if (cycleMap.get(targetModule) != null)
+ {
+ return pkgMap;
+ }
+
+ cycleMap.put(targetModule, targetModule);
+
+ // Loop through all wires for the target module's module dependencies
+ // and calculate the module's complete set of required packages (and
+ // their associated sources) and the complete set of required
+ // packages to be re-exported.
+ Map allRequiredMap = new HashMap();
+ Map reexportedPkgMap = new HashMap();
+ List<Wire> wires = targetModule.getWires();
+ for (int i = 0; (wires != null) && (i < wires.size()); i++)
+ {
+ // If the wire is a module dependency, then flatten it to packages.
+ if (wires.get(i).getCapability().getNamespace().equals(Capability.MODULE_NAMESPACE))
+ {
+ // Determine if required packages are re-exported.
+ boolean reexport = false;
+ R4Directive[] dirs = ((FelixRequirement) wires.get(i).getRequirement()).getDirectives();
+ for (int dirIdx = 0;
+ !reexport && (dirs != null) && (dirIdx < dirs.length); dirIdx++)
+ {
+ if (dirs[dirIdx].getName().equals(Constants.VISIBILITY_DIRECTIVE)
+ && dirs[dirIdx].getValue().equals(Constants.VISIBILITY_REEXPORT))
+ {
+ reexport = true;
+ }
+ }
+
+ // Recursively calculate the required packages for the
+ // wire's exporting module.
+ Map requiredMap = calculateExportedAndReexportedPackagesResolved(
+ wires.get(i).getExporter(), cycleMap);
+
+ // Merge the wires exported and re-exported packages
+ // into the complete set of required packages.
+ for (Iterator reqIter = requiredMap.entrySet().iterator(); reqIter.hasNext(); )
+ {
+ Map.Entry entry = (Map.Entry) reqIter.next();
+ String pkgName = (String) entry.getKey();
+
+ // Merge the current set of required packages into
+ // the overall complete set of required packages.
+ // We calculate all the required packages, because
+ // despite the fact that some packages will be required
+ // "privately" and some will be required "reexport", any
+ // re-exported packages will ultimately need to
+ // be combined with privately required packages,
+ // if the required packages overlap. This is one of the
+ // bad things about require-bundle behavior, it does not
+ // necessarily obey the visibility rules declared in the
+ // dependency.
+ ResolvedPackage rp = (ResolvedPackage) allRequiredMap.get(pkgName);
+ if (rp != null)
+ {
+ // Create the union of all packages.
+ ResolvedPackage rpReq = (ResolvedPackage) entry.getValue();
+ rp.merge(rpReq);
+ }
+ else
+ {
+ // Add package to required map.
+ allRequiredMap.put(pkgName, entry.getValue());
+ }
+
+ // Keep track of all required packages to be re-exported.
+ // All re-exported packages will need to be merged into the
+ // target module's package map and become part of its overall
+ // export signature.
+ if (reexport)
+ {
+ reexportedPkgMap.put(pkgName, pkgName);
+ }
+ }
+ }
+ }
+
+ // For the target module we have now calculated its entire set
+ // of required packages and their associated source capabilities in
+ // allRequiredMap and have calculated all packages to be re-exported
+ // in reexportedPkgMap. Add all re-exported required packages to the
+ // target module's package map since they will be part of its export
+ // signature.
+ for (Iterator iter = reexportedPkgMap.entrySet().iterator(); iter.hasNext(); )
+ {
+ String pkgName = (String) ((Map.Entry) iter.next()).getKey();
+ pkgMap.put(pkgName, allRequiredMap.get(pkgName));
+ }
+
+ // Now loop through the target module's export package capabilities and
+ // add the target module as a source for any exported packages.
+ List<Capability> caps = targetModule.getCapabilities();
+ for (int i = 0; (caps != null) && (i < caps.size()); i++)
+ {
+ if (caps.get(i).getNamespace().equals(Capability.PACKAGE_NAMESPACE))
+ {
+ String pkgName = (String)
+ caps.get(i).getAttribute(Capability.PACKAGE_ATTR).getValue();
+ ResolvedPackage rp = (ResolvedPackage) pkgMap.get(pkgName);
+ rp = (rp == null) ? new ResolvedPackage(pkgName, null) : rp;
+ rp.m_capList.add(caps.get(i));
+ pkgMap.put(rp.m_name, rp);
+ }
}
return pkgMap;
}
+ private static Map calculateCandidateRequiredPackages(
+ Module module, Capability capTarget, Map candidatesMap)
+ {
+//System.out.println("calculateCandidateRequiredPackages("+module+")");
+ Map cycleMap = new HashMap();
+ cycleMap.put(module, module);
+ return calculateExportedAndReexportedPackages(capTarget, candidatesMap, cycleMap);
+ }
+
private static void incrementCandidateConfiguration(List resolverList)
throws ResolveException
{
@@ -777,7 +1172,20 @@
// Get the current candidate set.
CandidateSet cs = (CandidateSet) candSetList.get(candSetIdx);
- if (importer != ((Capability) cs.m_candidates.get(cs.m_idx)).getModule())
+ // Create a module wire for module dependencies.
+ if (cs.m_requirement.getNamespace().equals(Capability.MODULE_NAMESPACE))
+ {
+ moduleWires.add(new Wire(
+ importer,
+ cs.m_requirement,
+ ((Capability) cs.m_candidates.get(cs.m_idx)).getModule(),
+ ((Capability) cs.m_candidates.get(cs.m_idx))));
+ }
+ // Create a package wire for package dependencies.
+ // Filter out the case where a module imports from
+ // itself, since the module should simply load from
+ // its internal class path in this case.
+ else if (importer != ((Capability) cs.m_candidates.get(cs.m_idx)).getModule())
{
// Add wire for imported package.
packageWires.add(new Wire(
Modified: felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/proto3/Proto3Resolver.java
URL: http://svn.apache.org/viewvc/felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/proto3/Proto3Resolver.java?rev=896679&r1=896678&r2=896679&view=diff
==============================================================================
--- felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/proto3/Proto3Resolver.java (original)
+++ felix/sandbox/rickhall/resolver/src/main/java/org/apache/felix/resolver/proto3/Proto3Resolver.java Wed Jan 6 21:35:18 2010
@@ -114,7 +114,7 @@
rethrow = null;
candidateMap = m_candidatePermutations.remove(0);
-dumpCandidateMap(candidateMap);
+//dumpCandidateMap(candidateMap);
try
{
@@ -137,7 +137,7 @@
{
throw rethrow;
}
-dumpModulePkgMap(modulePkgMap);
+//dumpModulePkgMap(modulePkgMap);
}
Map<Module, List<Wire>> wireMap =