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

      */
     private String mEscrowRawData;
     /** Collections of packages
      */
-    private ArrayList<Package> mPackageCollection = new ArrayList<Package>();
+    private PackageCollection mPackageCollection = new PackageCollection();
-    private ArrayList<Package> mPackageCollectionWip = new ArrayList<Package>();
+    private PackageCollection mPackageCollectionWip = new PackageCollection();
-    private ArrayList<Package> mPackageCollectionTest = new ArrayList<Package>();
+    private PackageCollection mPackageCollectionTest = new PackageCollection();
-    private ArrayList<Package> mPackageCollectionRipple = new ArrayList<Package>();
+    private PackageCollection mPackageCollectionRipple = new PackageCollection();
-    private ArrayList<Package> mPackageCollectionAll = new ArrayList<Package>();
+    private PackageCollection mPackageCollectionAll = new PackageCollection();
     /**index to current String item
      * @attribute
      */
     private int mBuildIndex;
             // Sort the collection by PVID
             //      Unit Test output order is known
             //      May assist in creating repeatable build orders
             //
-            Collections.sort(mPackageCollectionAll, Package.SeqComparator);
+            Collections.sort(mPackageCollectionAll.mCollection, Package.SeqComparator);
             //------------------------------------------------------------------------
             //    Process packages collected
             //    Determine and tag those we can't build
             phase.setPhase("processPackages");
             Package p = it.next();
             for (Iterator<PkgDependency> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+            {
                 PkgDependency depEntry = it2.next();
-                Package dependency = findPackage(depEntry.alias);
+                Package dependency = mPackageCollection.contains(depEntry.alias);
+                if (dependency != null)
-                depEntry.pkg = dependency;
+                	depEntry.pkg = dependency;
+            }
+        }
         // Detect and deal with circular dependencies
-        // Examine all packages under consideration
+        // Examine all packages in the Release. Other packages will be examined later
-        //
         phase.setPhase("Detect Circular Dependencies");
         mLogger.debug("planRelease deal with circular dependencies");
         for (Iterator<Package> it = mPackageCollectionAll.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
-            if ( p.hasCircularDependency( mPackageCollectionAll ) )
+            if ( p.hasCircularDependency( mPackageCollection ) )
+            {
                 mLogger.info("planRelease circular dependency detected {}", p.mAlias);
                 //  Force this package to be marked as having a circular dependency - even if its been excluded
                 p.mBuildFile = 0;
+            }
             for (Iterator<PkgDependency> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+            {
                 PkgDependency depEntry = it2.next();
-                Package dependency = findPackage(depEntry.alias);
+                Package dependency = mPackageCollection.contains(depEntry.alias);
-                if (dependency == ReleaseManager.NULL_PACKAGE)
+                if (dependency == null)
+                {
                     mLogger.info("planRelease dependency is not in the baseline {}", depEntry);
                     // Exclude the package
                     // max 50 chars
                     rippleBuildExclude(p, p.mId, "Package build dependency not in the release", -4);
                     //  Ensure that the package we are about to build is present in the mPackageCollection as its
                     //  this list that is used to generate the build.xml file - that may be a bad way to do it , but ...
                     //
                     //  Note: Can't really modify others as they will be used as dependencies
                     //
-                    Package pEntry = findPackage(build.mAlias);
-                    if ( pEntry != ReleaseManager.NULL_PACKAGE)
-                    {
-                        mPackageCollection.set(mReleaseManager.findPackageLastIndex, build);
-                        build.mIsNotReleased = false;
-                    } else {
-                        mPackageCollection.add(build);
+                    mPackageCollection.upsert(build);
-                        build.mIsNotReleased = false;
+                    build.mIsNotReleased = false;
-                    }
+                }
                 //
                 //  Report packages that are indirectly excluded
                 //  ie: They will not be built because one, or more, of their dependents is not buildable
                                 // package is not reproducible, discard it and its consumers
                                 //
                                 mLogger.warn("Excluded Package {}, {}", p, be );
                                 ArrayList<Package> toExclude = new ArrayList<Package>();
-                                toExclude.addAll(usedByAnyPackages(p, mPackageCollectionAll ));
+                                toExclude.addAll(usedByAnyPackages(p, mPackageCollection ));
                                 //  Process packages that we need to exclude indirectly
                                 //
                                 while ( ! toExclude.isEmpty())
+                                {
                                         pkg.mBuildFile = -5;
+                                    }
                                     // Determine all packages that use this excluded package
                                     // THAT WE HAVE NOT ALREADY PROCESSED - circular dependencies are a killer
-                                    ArrayList<Package> usedBy = usedByAnyPackages(pkg, mPackageCollectionAll );
+                                    ArrayList<Package> usedBy = usedByAnyPackages(pkg, mPackageCollection );
                                     for (Iterator<Package> it2 = usedBy.iterator(); it2.hasNext(); )
+                                    {
                                         Package uPkg = it2.next();
                                         if (!uPkg.mCheckedCircularDependency)
+                                        {
      * @param packageCollection - Base collection of packages to plan
      * @param mode - true: Include 'Ripples'
+     *
      * @return
      */
-    private PlanResults planCollection(String name, ArrayList<Package> packageCollection, boolean mode)
+    private PlanResults planCollection(String name, PackageCollection packageCollection, boolean mode)
+    {
         Phase phase = new Phase("Plan-" + name);
         ArrayList<PlannedPackage> ripplePlan = new ArrayList<PlannedPackage>();
         PlanResults results = new PlanResults();
      *                          as a part of the basic plan
      * @return
      */
     private PlanResults postRipplePlan(String name, PlanResults basicPlan, boolean mode) {
-        ArrayList<Package> fullPlanCollection = new ArrayList<Package>(mPackageCollection);
+        PackageCollection fullPlanCollection = new PackageCollection(mPackageCollection);
         ArrayList<Package> buildCandidates = new ArrayList<Package>();
-        buildCandidates.addAll(mPackageCollectionWip);
+        buildCandidates.addAll(mPackageCollectionWip.mCollection);
-        buildCandidates.addAll(mPackageCollectionRipple);
+        buildCandidates.addAll(mPackageCollectionRipple.mCollection);
         if ( !buildCandidates.isEmpty() )
+        {
             for (Iterator<Package> it = buildCandidates.iterator(); it.hasNext(); )
+            {
                 if (p.mBuildFile >= 0)
+                {
                     if (!mode)
+                    {
                         //  Exclude packages that would have been processed in the basicPlan
+                    	// TODO - Don't like scanning. SHould have a collection with a hash
                         for (Iterator<PlannedPackage> it1 = basicPlan.planCollection.iterator(); it1.hasNext(); )
+                        {
                             PlannedPackage pkg = it1.next();
                             if (pkg.mPkg == p)
+                            {
+                            }
+                        }
+                    }
                     mLogger.warn("Test Plan with {}", p);
-                    Package foundInRelease = mReleaseManager.findPackage(p.mAlias, fullPlanCollection);
-                    int foundIndex = mReleaseManager.findPackageLastIndex;
-                    if (foundInRelease == ReleaseManager.NULL_PACKAGE)
-                    {
-                        fullPlanCollection.add(p);
+                    fullPlanCollection.upsert(p);
-                    }
-                    else
-                    {
-                        fullPlanCollection.set(foundIndex, p);
-                    }
                     Package.resetCircularDependency (fullPlanCollection);
                     if ( p.hasCircularDependency( fullPlanCollection ) )
+                    {
                         mLogger.info("planRelease circular dependency detected {}", p);
     /**
      *  Calculate a collection of packages that use the named package
+     *
      * @param pkg - Package to process
-     * @param pkgCollection - collection of packages to scan
+     * @param packageCollection - collection of packages to scan
+     *
      * @return A collection of packages that actively 'use' the specified package
      */
-    private ArrayList<Package> usedByAnyPackages(Package pkg, ArrayList<Package> pkgCollection) {
+    private ArrayList<Package> usedByAnyPackages(Package pkg, PackageCollection packageCollection) {
         ArrayList<Package> usedBy = new ArrayList<Package>();
-        for (Iterator<Package> it = pkgCollection.iterator(); it.hasNext(); )
+        for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             for (Iterator<PkgDependency> it2 = p.mDependencyCollection.iterator(); it2.hasNext(); )
+            {
+     *
      *  These need o be rejected now as the the Master logic will plan a build a build if there is a daemon instruction
      *  present. If an instruction cannot be processed and is not removed, then the daemon will continuously 'plan'
      */
     private void reportUnsatisfiedDaemonInstructions() throws SQLException, Exception {
-        ArrayList<Package> toProcess = new ArrayList<Package>();
+        PackageCollection toProcess = new PackageCollection();
         toProcess.addAll(mPackageCollectionTest);
         toProcess.addAll(mPackageCollectionRipple);
         for (Iterator<Package> it = toProcess.iterator(); it.hasNext(); )
+        {
             //
             //  If the package is in the 'plan, then its not excluded
             //
             boolean isPlanned = false;
+//TODO Should mBuildOrder be  aPackageCollection
             for (Iterator<PlannedPackage> it1 = mBuildOrder.listIterator(); it1.hasNext(); )
+            {
                 PlannedPackage pkg = it1.next();
                 if (pkg.mPkg == p)
+                {
      * @param dpvId
      * @return true - specified pvid is a full member of the Release
      */
     private boolean isInRelease(Integer dpvId) {
-        boolean inRelease = false;
-        for ( Iterator<Package> it = mPackageCollection.iterator(); it.hasNext(); )
+        boolean inRelease = ( mPackageCollection.contains(dpvId) != null);
-        {
-            Package p = it.next();
-            if ( p.mId == dpvId )
-            {
-                inRelease = ! p.mIsNotReleased;
-                break;
-            }
-        }
         return inRelease;
+    }
     /** Reports what change in build exceptions happens as part of planRelease
             } else {
                 // Exclude and notify
                 mLogger.warn("reportChange add new exclusion: {}", buildExclusion );
                 buildExclusion.excludeFromBuild(mReleaseManager, mBaseline);
-                buildExclusion.email(this, mPackageCollectionAll);
+                buildExclusion.email(this, mPackageCollection);
                 counter++;
+            }
+        }
         mLogger.warn("reportChange exclusion count: {}", counter);
+    }
             mReleaseManager.disconnect();
+        }
+    }
     /**
-     * Find Package by package alias
-     * Searches the released package collection
-     * @param   alias               - alias of package to locate
-     * @return  Package with the matching mAlias or NULL_PACKAGE if no package has the mAlias
-     */
-    public Package findPackage(String alias)
-    {
-        mLogger.debug("findPackage");
-        Package retVal = mReleaseManager.findPackage(alias, mPackageCollection);
-        mLogger.debug("findPackage returned {}", retVal.mName);
-        return retVal;
-    }
-    /**
      * Sets the mBuildFile to the specified value for the package
      * Does not handle dependent packages - this will be done later
+     *
      * @param p             The package being excluded
      * @param rootPvId      The PVID of the package that is causing the exclusion. Null or -ve values are special

Subversion Repositories DevTools

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