WebSVN – DevTools – Diff – /buildtool/branches/planMetrics2/src/main/java/com/erggroup/buildtool/ripple/Package.java

 	 *     User resets to NULL when the ripple can be resumed. This is stored as an 'n'
+	 *
 	 */
     public char mRippleStop;
-    /**
-     *  The calculated ripple build plan for this package
-     *  Will not be calculated for all packages, just those of interest
-     *  All packages that can (not must) be built when this package is built
-     *  The list will not include packages that cannot be built at the moment
-     *
-     *  Does not include this package
-     */
-    public ArrayList<Package> mRipplePlan = null;
     /** The duration (seconds) of the last build of this package
      *  Used to estimate the cost of building the package
      *  A WIP packages gets the buildTime of the package its based upon
      */
     public int mBuildTime;
-    /** Calculated time ( seconds) that is may take to build this package and then ripple packages that depend on it
-     *  both directly and indirectly. Based on mRipplePlan.
-     */
-    public int mRippleTime = 0;
     /** Used in the calculation of a ripple plan
+     *
      */
     public int mRippleOrder = 0;
      * Constructor for unit test purposes
      * Performs a partial copy of a package - sufficient for test purposes
      * @param base      - Base package
      * @param newPvId   - New pvid of the package
      */
-    @SuppressWarnings("unchecked")
     public Package(int newPvId, Package base) {
         mId = newPvId;
         mPid = base.mPid;
         mName = base.mName;
         mRippleField = base.mRippleField;
         mBuildTime = base.mBuildTime;
         mHasAutomatedUnitTests = base.mHasAutomatedUnitTests;
         mSeqId = base.mSeqId;
-        mBuildFailureEmailCollection = (Vector<String>) base.mBuildFailureEmailCollection.clone();
+        mBuildFailureEmailCollection = new Vector<String>(base.mBuildFailureEmailCollection);
-        mPackageDependencyCollection = (Vector<Package>) base.mPackageDependencyCollection.clone();
+        mPackageDependencyCollection = new Vector<Package>(base.mPackageDependencyCollection);
-        mDependencyIDCollection = (Vector<Integer>) base.mDependencyIDCollection.clone();
+        mDependencyIDCollection = new Vector<Integer>(base.mDependencyIDCollection);
-        mDependencyCollection = (Vector<String>) base.mDependencyCollection.clone();
+        mDependencyCollection = new Vector<String>(base.mDependencyCollection);
-        mBuildStandardCollection = (Vector<BuildStandard>) base.mBuildStandardCollection.clone();
+        mBuildStandardCollection = new Vector<BuildStandard>( base.mBuildStandardCollection);
+    }
+    /** Generate a nice text string useful for debugging
+     *
+     */
+    public String toString()
+    {
+        return mId + ":" + mAlias;
+    }
     /**
      * accessor for unit test purposes
      */
     public int getId()
         mLogger.error("completeTest. Returning");
+    }
     /**
-     * Returns true if the package is a part of a circular dependency
+     * Returns true if the package is a part of a circular dependency within the provided collection
+     *
      * If the package depends on a package with a circular dependency then the function
      * will return false.
      */
-    public boolean hasCircularDependency(RippleEngine ripEng)
+    public boolean hasCircularDependency(ArrayList<Package> packageCollection)
+    {
         mLogger.debug("hasCircularDependency: {}", mAlias);
-        boolean retVal = detectCircularDependency(mAlias, ripEng, null);
+        boolean retVal = detectCircularDependency(mAlias, packageCollection, null);
         mLogger.info("hasCircularDependency returned {} ", retVal);
         return retVal;
+    }
+    /** Reset the circular dependency testing information
+     *
+     * @param packageCollection - Collection of packages to process
+     */
+    public static void resetCircularDependency(ArrayList<Package> packageCollection)
+    {
+        for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+        {
+            Package p = it.next();
+            p.mCheckedCircularDependency = false;
+            p.mHasCircularDependency = false;
+            p.mBreadCrumb = 0;
+        }
+    }
     /**
      * Returns true is a part of a circular dependency
      * Will examine all the packages sub dependencies and mark those that do have a
      * circular dependency.
+     *
      *  Assumes that the caller will walk ALL packages and flag those with a circular
      *  dependence AND those that depend on that package.
+     *
      */
-    private boolean detectCircularDependency(String alias, RippleEngine ripEng, Package parent)
+    private boolean detectCircularDependency(String alias, ArrayList<Package> packageCollection, Package parent)
+    {
         mLogger.debug("detectCircularDependency");
         boolean retVal = false;
         // if this package has yet to be checked for circular dependency
                 // Recurse down the dependencies and sub dependencies
                 for (Iterator<String> it2 = mDependencyCollection.iterator(); it2.hasNext();)
+                {
                     String dependencyAlias = it2.next();
+                    // Scan the collection looking for the specified package alias
+                    for (Iterator<Package> it = packageCollection.iterator(); it.hasNext();)
+                    {
+                        Package dependency = it.next();
-                    Package dependency = ripEng.findPackage(dependencyAlias);
+                        if ( dependency.mAlias.compareTo( dependencyAlias ) == 0 )
+                        {
-                    dependency.detectCircularDependency(alias, ripEng, this);
+                            dependency.detectCircularDependency(alias, packageCollection, this);
+                            break;
+                        }
+                    }
+                }
                 if (mBreadCrumb == 2)
+                {
                     mHasCircularDependency = true;
+    {
         for (Iterator<Package> it = al.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
             p.mIsProcessed = false;
+            p.mProcessed = false;
+            if (p.mBuildFile > 0)
+                p.mBuildFile = 0;
+            p.mRippleOrder = 0;
+        }
+    }
     /** Reset the rippleOrder flag on a collection of packages
+     *
         public int compare (Package p1, Package p2) {
                 return p1.mSeqId - p2.mSeqId;
+        }
     };
-    /** Comparator for sorting package collections by mRippleTimme and mRippleOrder
+    /** Comparator for sorting package collections by mBuildTime and mRippleOrder
      *  Preserve rippleOrder
+     *
      */
-    public static final Comparator<Package> PlanComparator = new Comparator<Package>() {
+    public static final Comparator<Package> BuildOrderComparitor = new Comparator<Package>() {
         /**
          * Returns -ve: p1 is less than p2
          *           0: p1 = p2
          *         +ve: p1 > p2
          */
         public int compare (Package p1, Package p2) {
             if (p1.mRippleOrder == p2.mRippleOrder)
+            {
-                return p1.mRippleTime - p2.mRippleTime;
+                return p1.mBuildTime - p2.mBuildTime;
+            }
             return p1.mRippleOrder - p2.mRippleOrder;
+        }
     };
-    /** Comparator for sorting package collections by mRippleTimme (only)
-     *
-     */
-    public static final Comparator<Package> RippleTimeComparator = new Comparator<Package>() {
-        /**
-         * Returns -ve: p1 is less than p2
-         *           0: p1 = p2
-         *         +ve: p1 > p2
-         */
-        public int compare (Package p1, Package p2) {
-            return p1.mRippleTime - p2.mRippleTime;
-        }
-    };
     /**
      * entity class supporting the ERG version numbering standard:
      * <major>.<minor>.<patch/build> patch/build is at least a 4 digit number
      * whose last 3 digits represent the build
      */

Subversion Repositories DevTools

(root)/buildtool/branches/planMetrics2/src/main/java/com/erggroup/buildtool/ripple/Package.java – Rev 7077 → 7078