WebSVN – DevTools – Diff – /buildtool/trunk/src/main/java/com/erggroup/buildtool/ripple/RippleEngine.java

                         //      WIPs/RIPPLES done in the course of doing the basic plan
                         mLogger.warn("Use basic plan, then modified full plan");
                         mBuildOrder.addAll(basicPlan.planCollection);
                         fullPlan = postRipplePlan("Full-Ripples", basicPlan, false);
+                        //  Insert a marker package to indicate a 'newPlan'
+                        PlannedPackage pp = new PlannedPackage( new Package() );
+                        pp.mBuildLevel = -1;
+                        mBuildOrder.add(pp);
                         mBuildOrder.addAll(fullPlan.planCollection);
                     } else {
                         //  Use the full plan
                         mLogger.warn("Use full plan");
                  //
                  //  Examine the build order and 'delete' entries with a -ve mBuildFile
                  //  These will be the product of pvApply errors and the packages that depend on them
                  //
-                 //  Insert a dummy marker between build plans
-                 //     Detect the index of the insertion point
-                 //
-                 int lastLevel = -1;
-                 int listIndex = 0;
-                 int insertMarker = -1;
                  for (Iterator<PlannedPackage> it = mBuildOrder.listIterator(); it.hasNext(); )
+                 {
                      PlannedPackage pkg = it.next();
                      if (pkg.mPkg.mBuildFile < 0)
+                     {
                          it.remove();
                          mLogger.warn("Purge mBuildOrder {}", pkg.mPkg);
                          continue;
+                     }
-                     if ( pkg.mBuildLevel < lastLevel && insertMarker < 0)
-                     {
-                         insertMarker = listIndex;
-                     }
-                     listIndex++;
-                     lastLevel = pkg.mBuildLevel;
+                 }
+                 //
+                 // If the first entry is a 'new Plan' marker, then remove it
+                 //     It will be the result of applyPvs that failed
-                 if (insertMarker > 0)
+                 if ( !mBuildOrder.isEmpty() )
+                 {
-                     PlannedPackage pp = new PlannedPackage( new Package() );
+                     PlannedPackage pkg = mBuildOrder.get(0);
-                     pp.mBuildLevel = -1;
+                     if (pkg.mBuildLevel < 0)
-                     mBuildOrder.add(insertMarker, pp);
+                         mBuildOrder.remove(0);
+                 }
                 //
                 //  To fit in with the old algorithm ( ie: could be improved )
                 //  Insert marks into all packages
         //  Basically:
         //      Scan the collection looking for any package whose dependencies do not exist in the collection
         //      or they have been allocated a build level.
         //
         //      Need to do this in waves so that we can correctly determine the build level.
+        //
         //
+        //  Need two metrics out of this process
+        //      buildGroup - all packages in a given group depend entirely on packages in lower numbers groups
+        //      buildLevel - This is a function of the number of parallel builds that can be performed
+        //                   and
         //
         for (Iterator<PlannedPackage> it = ripplePlan.iterator(); it.hasNext(); )
+        {
             PlannedPackage p = it.next();
             p.mProcessed = true;
+                    }
+                }
+            }
             //  Mark all the packages at this level as have been processed
             //  Cannot do this while we are determining the packages in the level
             for (Iterator<PlannedPackage> it = thisLevel.iterator(); it.hasNext(); )
+            {
                 PlannedPackage p = it.next();
                 p.mProcessed = false;
+            }
+    }
     /**
      *  Calculate a collection of packages that actively use the named package
      *  A consumer package does NOT use the named package,
+     *      If the package is marked as advisoryRipple
      *      If the consumer is an SDK or is Pegged
-     *      If the consumer is marked as advisoryRipple
      *      If the consumer cannot be built
+     *
+     *  Used when planning which packages need to be built
+     *
      * @param pkg - Package to process
      * @param planCollection - collection of packages to scan
+     *
      * @return A collection of packages that actively 'use' the specified package
      */
     private ArrayList<PlannedPackage> usedByPackages(PlannedPackage pkg, ArrayList<PlannedPackage> planCollection) {
         ArrayList<PlannedPackage> usedBy = new ArrayList<PlannedPackage>();
-        for (Iterator<PlannedPackage> it = planCollection.iterator(); it.hasNext(); )
+        //  If 'this' package is marked as advisory, then don't ripple its consumers
+        if ( !pkg.mPkg.mAdvisoryRipple )
+        {
-            PlannedPackage p = it.next();
-            //  Is this package 'actively used' in the current build
+            for (Iterator<PlannedPackage> it = planCollection.iterator(); it.hasNext(); )
-            if (p.mPkg.mBuildFile >= 0)
+            {
+                PlannedPackage p = it.next();
-                for (Iterator<PkgDependency> it2 = p.mPkg.mDependencyCollection.iterator(); it2.hasNext(); )
+                //  If the (potential) consumer is an SDK or is Pegged, then we don't ripple its consumer
+                if  (!(p.mPkg.mIsSdk || p.mPkg.mIsPegged))
+                {
+                    //  Is this package 'actively used' in the current build
+                    if (p.mPkg.mBuildFile >= 0)
+                    {
+                        for (Iterator<PkgDependency> it2 = p.mPkg.mDependencyCollection.iterator(); it2.hasNext(); )
+                        {
-                    PkgDependency depEntry = it2.next();
+                            PkgDependency depEntry = it2.next();
-                    if (  pkg.mPkg.mAlias.compareTo( depEntry.alias ) == 0  ) {
+                            if (  pkg.mPkg.mAlias.compareTo( depEntry.alias ) == 0  ) {
-                        //  Have found a consumer of 'pkg'
+                                //  Have found a consumer of 'pkg'
-                        usedBy.add(p);
+                                usedBy.add(p);
+                                break;
-                        break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
         return usedBy;
+    }
     /**
      *  Calculate a collection of packages that use the named package
+     *
+     *  Used when determining which packages to exclude from a build
+     *
      * @param pkg - Package to process
      * @param packageCollection - collection of packages to scan
+     *
      * @return A collection of packages that actively 'use' the specified package

Subversion Repositories DevTools

(root)/buildtool/trunk/src/main/java/com/erggroup/buildtool/ripple/RippleEngine.java – Rev 7201 → 7231