felix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rickh...@apache.org
Subject svn commit: r546926 - /felix/trunk/framework/src/main/java/org/apache/felix/framework/searchpolicy/R4SearchPolicyCore.java
Date Wed, 13 Jun 2007 15:37:40 GMT
Author: rickhall
Date: Wed Jun 13 08:37:39 2007
New Revision: 546926

URL: http://svn.apache.org/viewvc?view=rev&rev=546926
Log:
Added experimental "implicit import" concept that allows exporters to push
additional imports to importers of their packages; this feature will likely
be removed in the future.

Modified:
    felix/trunk/framework/src/main/java/org/apache/felix/framework/searchpolicy/R4SearchPolicyCore.java

Modified: felix/trunk/framework/src/main/java/org/apache/felix/framework/searchpolicy/R4SearchPolicyCore.java
URL: http://svn.apache.org/viewvc/felix/trunk/framework/src/main/java/org/apache/felix/framework/searchpolicy/R4SearchPolicyCore.java?view=diff&rev=546926&r1=546925&r2=546926
==============================================================================
--- felix/trunk/framework/src/main/java/org/apache/felix/framework/searchpolicy/R4SearchPolicyCore.java
(original)
+++ felix/trunk/framework/src/main/java/org/apache/felix/framework/searchpolicy/R4SearchPolicyCore.java
Wed Jun 13 08:37:39 2007
@@ -1036,7 +1036,19 @@
         // Get the package map for the target module, which is a
         // map of all packages accessible to the module and their
         // associated package sources.
-        Map pkgMap = getModulePackages(moduleMap, targetModule, candidatesMap);
+        Map pkgMap = null;
+        try
+        {
+            pkgMap = getModulePackages(moduleMap, targetModule, candidatesMap);
+        }
+        catch (ResolveException ex)
+        {
+            m_logger.log(
+                Logger.LOG_DEBUG,
+                "Constraint violation for " + targetModule + " detected.",
+                ex);
+            return false;
+        }
 
         // Loop through all of the target module's accessible packages and
         // verify that all package sources are consistent.
@@ -1059,7 +1071,19 @@
 
         // Now we need to calculate the "uses" constraints of every package
         // accessible to the target module based on the current candidates.
-        Map usesMap = calculateUsesConstraints(targetModule, moduleMap, candidatesMap);
+        Map usesMap = null;
+        try
+        {
+            usesMap = calculateUsesConstraints(targetModule, moduleMap, candidatesMap);
+        }
+        catch (ResolveException ex)
+        {
+            m_logger.log(
+                Logger.LOG_DEBUG,
+                "Constraint violation for " + targetModule + " detected.",
+                ex);
+            return false;
+        }
 
         // Verify that none of the implied "uses" constraints in the uses map
         // conflict with anything in the target module's package map.
@@ -1121,6 +1145,7 @@
 
     private Map calculateUsesConstraints(
         IModule targetModule, Map moduleMap, Map candidatesMap)
+        throws ResolveException
     {
 //System.out.println("calculateUsesConstraints("+targetModule+")");
         // Map to store calculated uses constraints. This maps a
@@ -1158,6 +1183,7 @@
     private Map calculateUsesConstraints(
         PackageSource psTarget, Map moduleMap, Map usesMap,
         Map cycleMap, Map candidatesMap)
+        throws ResolveException
     {
 //System.out.println("calculateUsesConstraints2("+psTarget.m_module+")");
         // If we are in a cycle, then return for now.
@@ -1216,6 +1242,7 @@
     }
 
     private Map getModulePackages(Map moduleMap, IModule module, Map candidatesMap)
+        throws ResolveException
     {
         Map map = (Map) moduleMap.get(module);
 
@@ -1247,6 +1274,7 @@
      *         is a ResolvedPackage.
     **/
     private Map calculateModulePackages(IModule module, Map candidatesMap)
+        throws ResolveException
     {
 //System.out.println("calculateModulePackages("+module+")");
         Map importedPackages = calculateImportedPackages(module, candidatesMap);
@@ -1285,6 +1313,7 @@
     }
 
     private Map calculateImportedPackages(IModule targetModule, Map candidatesMap)
+        throws ResolveException
     {
         return (candidatesMap.get(targetModule) == null)
             ? calculateImportedPackagesResolved(targetModule)
@@ -1292,6 +1321,7 @@
     }
 
     private Map calculateImportedPackagesUnresolved(IModule targetModule, Map candidatesMap)
+        throws ResolveException
     {
 //System.out.println("calculateImportedPackagesUnresolved("+targetModule+")");
         Map pkgMap = new HashMap();
@@ -1316,6 +1346,27 @@
                 ResolvedPackage rp = new ResolvedPackage(pkgName);
                 rp.m_sourceList.add(ps);
                 pkgMap.put(rp.m_name, rp);
+                // TODO: FRAMEWORK - Experimental implicit wire concept to try
+                //       to deal with code generation.
+                // Get implicitly imported packages as defined by the provider
+                // of our imported package.
+                Map implicitPkgMap = calculateImplicitImportedPackages(ps, candidatesMap,
new HashMap());
+                // Merge the implicitly imported packages with our imports and
+                // verify that there is no overlap.
+                for (Iterator i = implicitPkgMap.entrySet().iterator(); i.hasNext(); )
+                {
+                    Map.Entry entry = (Map.Entry) i.next();
+                    if (pkgMap.get(entry.getKey()) != null)
+                    {
+                        throw new ResolveException(
+                            "Implicit import of "
+                            + entry.getKey()
+                            + " duplicates an existing import.",
+                            targetModule,
+                            cs.m_requirement);
+                    }
+                    pkgMap.put(entry.getKey(), entry.getValue());
+                }
             }
         }
 
@@ -1323,6 +1374,7 @@
     }
 
     private Map calculateImportedPackagesResolved(IModule targetModule)
+        throws ResolveException
     {
 //System.out.println("calculateImportedPackagesResolved("+targetModule+")");
         Map pkgMap = new HashMap();
@@ -1347,6 +1399,84 @@
         return pkgMap;
     }
 
+    private Map calculateImplicitImportedPackages(
+        PackageSource psTarget, Map candidatesMap, Map cycleMap)
+    {
+        return (candidatesMap.get(psTarget.m_module) == null)
+            ? calculateImplicitImportedPackagesResolved(psTarget, cycleMap)
+            : calculateImplicitImportedPackagesUnresolved(psTarget, candidatesMap, cycleMap);
     
+    }
+
+    // TODO: FRAMEWORK - This is currently not defined recursively, but it should be.
+    //       Currently, it only assumes that a provider can cause implicit imports for
+    //       packages that it exports.
+    private Map calculateImplicitImportedPackagesUnresolved(PackageSource psTarget, Map candidatesMap,
Map cycleMap)
+    {
+        Map pkgMap = new HashMap();
+
+        R4Directive[] dirs = ((Capability) psTarget.m_capability).getDirectives();
+        if (dirs != null)
+        {
+            for (int dirIdx = 0; dirIdx < dirs.length; dirIdx++)
+            {
+                if (dirs[dirIdx].getName().equals("x-implicitwire"))
+                {
+                    String[] pkgs = ManifestParser.parseDelimitedString(dirs[dirIdx].getValue(),
",");
+                    for (int pkgIdx = 0; pkgIdx < pkgs.length; pkgIdx++)
+                    {
+                        ResolvedPackage rp = new ResolvedPackage(pkgs[pkgIdx].trim());
+                        rp.m_sourceList.add(
+                            new PackageSource(
+                                psTarget.m_module,
+                                getExportPackageCapability(psTarget.m_module, pkgs[pkgIdx])));
+                        pkgMap.put(rp.m_name, rp);
+                    }
+                }
+            }
+        }
+
+        return pkgMap;
+    }
+
+    // TODO: FRAMEWORK - This is currently not defined recursively, but it should be.
+    //       Currently, it only assumes that a provider can cause implicit imports for
+    //       packages that it exports.
+    private Map calculateImplicitImportedPackagesResolved(PackageSource psTarget, Map cycleMap)
+    {
+        Map pkgMap = new HashMap();
+
+        R4Directive[] dirs = ((Capability) psTarget.m_capability).getDirectives();
+        if (dirs != null)
+        {
+            for (int dirIdx = 0; dirIdx < dirs.length; dirIdx++)
+            {
+                if (dirs[dirIdx].getName().equals("x-implicitwire"))
+                {
+                    String[] pkgs = ManifestParser.parseDelimitedString(dirs[dirIdx].getValue(),
",");
+                    for (int pkgIdx = 0; pkgIdx < pkgs.length; pkgIdx++)
+                    {
+                        ResolvedPackage rp = new ResolvedPackage(pkgs[pkgIdx].trim());
+                        rp.m_sourceList.add(
+                            new PackageSource(
+                                psTarget.m_module,
+                                getExportPackageCapability(psTarget.m_module, pkgs[pkgIdx])));
+                        pkgMap.put(rp.m_name, rp);
+                    }
+                }
+            }
+        }
+
+        return pkgMap;
+    }
+
+    private Map calculateCandidateImplicitImportedPackages(IModule module, PackageSource
psTarget, Map candidatesMap)
+    {
+//System.out.println("calculateCandidateImplicitPackages("+module+")");
+        Map cycleMap = new HashMap();
+        cycleMap.put(module, module);
+        return calculateImplicitImportedPackages(psTarget, candidatesMap, cycleMap);
+    }
+
     private Map calculateExportedPackages(IModule targetModule)
     {
 //System.out.println("calculateExportedPackages("+targetModule+")");
@@ -1528,7 +1658,7 @@
                 // current candidate.
                 Map requiredMap = calculateExportedAndReexportedPackages(ps, candidatesMap,
cycleMap);
 
-                // Merge the candidate's exported and re-exported packages
+                // Merge the candidate's exported and required packages
                 // into the complete set of required packages.
                 for (Iterator reqIter = requiredMap.entrySet().iterator(); reqIter.hasNext();
)
                 {
@@ -1902,11 +2032,29 @@
             }
             else
             {
+                // Add wire for imported package.
                 packageWires.add(new R4Wire(
                     importer,
                     cs.m_requirement,
                     cs.m_candidates[cs.m_idx].m_module,
                     cs.m_candidates[cs.m_idx].m_capability));
+
+                // TODO: FRAMEWORK - The following is part of an experimental 
+                //       implicit imported wire concept. The above code is how
+                //       the wire should normally be created.
+                // Add wires for any implicitly imported package from provider.
+                Map pkgMap = calculateCandidateImplicitImportedPackages(
+                    importer, cs.m_candidates[cs.m_idx], candidatesMap);
+                for (Iterator i = pkgMap.entrySet().iterator(); i.hasNext(); )
+                {
+                    Map.Entry entry = (Map.Entry) i.next();
+                    ResolvedPackage rp = (ResolvedPackage) entry.getValue();
+                    packageWires.add(new R4Wire(
+                        importer,
+                        cs.m_requirement, // TODO: This is not really correct.
+                        ((PackageSource) rp.m_sourceList.get(0)).m_module,
+                        ((PackageSource) rp.m_sourceList.get(0)).m_capability));
+                }
             }
 
             // Create any necessary wires for the selected candidate module.
@@ -2817,4 +2965,4 @@
 
         return sb.toString();
     }
-}
\ No newline at end of file
+}



Mime
View raw message