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

 package com.erggroup.buildtool.ripple;
 import java.io.File;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Vector;
-import java.util.Comparator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import com.erggroup.buildtool.ripple.ReleaseManager.BuildReason;
      * instance identifier
+     *
      * @attribute
      */
     public String mVersion = new String();
+    /**
+     * If this package is a candidate for building, then this value will be calculated
+     * and will  be used if the package is selected for building
+     */
+    public String mNextVersion = null;
     /**
      * Version string as specified by the user. Used with a ripple type of 'F'
      */
     String mFixedVersion = new String();
      */
     public boolean mIsBuildable = true;
     /**
      * determines the build file the package is built in, or not
-     * @param   1 Post Plan: build file - Result of planning
+     * <br>   1 Post Plan: build file - Result of planning
-     * @param   2 Post Plan: Future build requirement
+     * <br>   2 Post Plan: Future build requirement
-     * @param   3 Post Plan: Package has no build requirement
+     * <br>   3 Post Plan: Package has no build requirement
-     * @param   0 not yet processed (initial value)
+     * <br>   0 not yet processed (initial value)
-     * @param  -1 not reproducible
+     * <br>  -1 not reproducible
-     * @param  -2 escrow: not reproducible on the build platforms configured for this release
+     * <br>  -2 escrow: not reproducible on the build platforms configured for this release
-     * @param  -3 daemon: do not ripple
+     * <br>  -3 daemon: do not ripple
-     * @param  -4 directly dependent on package versions not in the baseline
+     * <br>  -4 directly dependent on package versions not in the baseline
-     * @param  -5 indirectly dependent on package versions which are not reproducible due to detected fault
+     * <br>  -5 indirectly dependent on package versions which are not reproducible due to detected fault
-     * @param  -6 circular dependency
+     * <br>  -6 circular dependency
-     * @param  -7 Pegged or SDK Imported package not in dpkg_archive
+     * <br>  -7 Pegged or SDK Imported package not in dpkg_archive
-     * @param  -8 Pegged or SDK Imported package
+     * <br>  -8 Pegged or SDK Imported package
-     * @param  -9 Rejected Daemon Instruction
+     * <br>  -9 Rejected Daemon Instruction
-     * @param  -10 UnBuildable Package not in dpkg_archive
+     * <br>  -10 UnBuildable Package not in dpkg_archive
-     * @param  -11 Marked as RippleStop
+     * <br>  -11 Marked as RippleStop
+     *
      */
     int mBuildFile = 0;
     /** Retained reason the package will not be built
     /**
      * non zero instruction number when it is determined to be ripple built by force
+     *
      * @attribute
      */
-    int mForcedRippleInstruction = 0;
+    public int mForcedRippleInstruction = 0;
     /**
      * test build - non zero instruction number when it is determined to be test built
+     *
      * @attribute
      */
-    int mTestBuildInstruction = 0;
+    public int mTestBuildInstruction = 0;
-    /**
-     * test build - Package PVID
-     *
-     * @attribute
-     */
-    int mTestBuildPvId = -1;
-    /**
-     * test build email destination
-     * Used by all daemon instructions to retain instigator of the instruction
-     *
-     * @attribute
-     */
-    String mTestBuildEmail;
-    /**
-     * test build - Version Control System Tag
-     *
-     * @attribute
-     */
-    String mTestBuildVcsTag = new String();
-    /**
-     * test build - build standards
-     *
-     * @attribute
-     */
-    Vector<BuildStandard> mTestBuildStandardCollection = new Vector<BuildStandard>();
-    /**
-     * test build - build dependencies by package alias
-     *
-     * @attribute
-     */
-    Vector<String> mTestBuildDependencyCollection = new Vector<String>();
-    /**
-     * test build - package has build dependencies
-     */
-	public boolean mTestBuildHasAutomatedUnitTests;
     /**
      * build dependencies by pv_id (-1 or not used for planned dependencies)
+     *
      * @attribute
      * Planned packages (WIPS) need calculate a new version number
      * This should be based on the Version of the package that the WIP was based upon
      */
 	public String mPrevVersion;
-	/** Used to preserve the basic ordering of the package list(s)
+    /** Used to preserve the basic ordering of the package list(s)
-	 *  Only valid for the duration of the comparison sorts
+     *  Only valid for the duration of the comparison sorts
-	 */
+     */
-	int mSeqId;
+    int mSeqId;
 	/** Indicates that the package not be ripple built at this time
 	 *  Sequence is:
 	 *     User sets to 's'
 	 *     This buildtool will set to 'w' when a ripple has been detected
 	 *     User resets to NULL when the ripple can be resumed. This is stored as an 'n'
      *  Used to estimate the cost of building the package
      *  A WIP packages gets the buildTime of the package its based upon
      */
     public int mBuildTime;
+    /** Set to indicate that the package is NOT a part of the full release set
+     *  The package is a WIP, TestBuild or a ForcedRipple
+     *
+     *   Used to simplify detection of such packages and to limit processing of these packages
+     *   May be cleared if the package is added to the full set
+     */
+    public boolean mIsNotReleased = false;
+    /** Used by some algorithms for various indications
+     *
+     */
+    public boolean mIsProcessed = false;
     /**
      * Constructor
      * Used to create planned packages. In these packages the change_type is significant
+     *
      * @param pkg_id	   Package Name Identifier
      * @param alias        Package Alias
      * @param pkg_vcs_tag  Vcs Tag
      * @param ripple_field Ripple Field
      * @param change_type  Change Type
      */
-    public Package(int pkg_id, int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag,
+    public Package(int pkg_id, int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag, char ripple_field, char change_type)
-            char ripple_field, char change_type)
+    {
         mLogger.debug("Package 1: pv_id " + pv_id + " pkg_name " + pkg_name + " v_ext " + v_ext + " alias " + alias
                 + " pkg_vcs_tag " + pkg_vcs_tag + " change_type " + change_type);
         mId = pv_id;
         mName = pkg_name;
      * @param v_ext        Package Suffix
      * @param alias        Package Alias
      * @param pkg_vcs_tag  Vcs Tag
      * @param ripple_field Ripple Field
      */
-    public Package(int pkg_id,int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag,
+    public Package(int pkg_id,int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag, char ripple_field)
-            char ripple_field)
+    {
         mLogger.debug("Package 2: pv_id " + pv_id + " pkg_name " + pkg_name + " pkg_version " + pkg_version + " v_ext "
                 + v_ext + " alias " + alias + " pkg_vcs_tag " + pkg_vcs_tag + " ripple_field " + ripple_field);
         mId = pv_id;
         mName = pkg_name;
         mAlias = "null";
         mVcsTag = "null";
+    }
     /**
-     * Constructor for test build purposes
+     * Constructor for unit test purposes
-     * Used when a test build package does not exist in the current package set
+     *  Will invoke applyPV and save the results for the UTF framework
-     *
-     */
-    Package(int pkg_id, int pv_id, String pkg_name, String v_ext, String alias, String pkg_vcs_tag, int testBuildInstruction, String email)
-    {
-        mLogger.debug("Package 4: pkg_name " + pkg_name + " v_ext " + v_ext + " alias " + alias + " pkg_vcs_tag "
-                + pkg_vcs_tag);
-        // don't need pv_id
-        mId = -1;
-        mName = pkg_name;
-        mPid = pkg_id;
-        // avoid interaction with real versions
-        mVersion = "0.0.0000";
-        mExtension = v_ext;
-        mAlias = alias;
-        mTestBuildInstruction = testBuildInstruction;
-        mTestBuildEmail = email;
-        mTestBuildVcsTag = pkg_vcs_tag;
-        mTestBuildPvId = pv_id;
-        mTestBuildHasAutomatedUnitTests = false;
-    }
-    /**
-     * constructor for unit test purposes
      */
     public Package(ReleaseManager rm, String version, int majorLimit, int minorLimit, int patchLimit, int buildNumberLimit)
+    {
         mId = -1;
         mRippleField.setLimit();
             mRippleField.setBuild();
+        }
         try
+        {
-            mId = applyPV(rm, 0);
+            mId = applyPV(rm);
         } catch (Exception e)
+        {
+        }
+    }
     /**
+     * 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
+     */
+    public Package(int newPvId, Package base) {
+        mId = newPvId;
+        mPid = base.mPid;
+        mName = base.mName;
+        mExtension = base.mExtension;
+        mVersion = base.mVersion;
+        mAlias = base.mAlias;
+        mVcsTag = base.mVcsTag;
+        mFixedVersion = base.mFixedVersion;
+        mChangeType = base.mChangeType;
+        mRippleField = base.mRippleField;
+        mBuildTime = base.mBuildTime;
+        mHasAutomatedUnitTests = base.mHasAutomatedUnitTests;
+        mSeqId = base.mSeqId;
+        mBuildFailureEmailCollection = new Vector<String>(base.mBuildFailureEmailCollection);
+        mPackageDependencyCollection = new Vector<Package>(base.mPackageDependencyCollection);
+        mDependencyIDCollection = new Vector<Integer>(base.mDependencyIDCollection);
+        mDependencyCollection = new Vector<String>(base.mDependencyCollection);
+        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()
+    {
         return mId;
     public String getVersion()
+    {
         return mVersion;
+    }
+    /**
-    /** Set the sequence of all packages in the list
-     *  Used so that the UnitTestComparator function can preserve the
-     *  basic ordering of the list
+     * accessor for unit test purposes
      */
-    public static void setSequence(ArrayList<Package> al)
+    public String getNextVersion()
+    {
-        int seq = 1;
-        for (Iterator<Package> it = al.iterator(); it.hasNext(); )
-        {
-            Package p = it.next();
-            p.mSeqId = seq++;
+        return mNextVersion;
-        }
+    }
-    /** Comparator for sorting unit tests
-     *      Used to sort a list of packages such that the package with the lowest mTestBuildInstruction
-     *      is at the head of the list.
-     *
-     *      Packages without a unit test are sorted by mSeqId to preserve the basic
-     *      ordering of the list.
-     */
-    public static final Comparator<Package> UnitTestComparator = new Comparator<Package>() {
-        /**
-         * Returns -ve: p1 is less than p2
-         *           0: p1 = p2
-         *         +ve: p1 > p2
-         */
-        public int compare (Package p1, Package p2) {
-            // Both are test builds
-            if (p1.mTestBuildInstruction > 0 && p2.mTestBuildInstruction > 0)
-                return p1.mTestBuildInstruction - p2.mTestBuildInstruction;
-            // Neither is a test build
-            if (p1.mTestBuildInstruction == 0 && p2.mTestBuildInstruction == 0)
-                return p1.mSeqId - p2.mSeqId;
-            // Only one is a test build
-            if (p1.mTestBuildInstruction > 0)
-                return -1;
-            return 1;
-        }
-    };
     /**
      * returns true if mBuildStandardCollection is not empty
      */
     boolean isReproducible()
+    {
-        mLogger.debug("isReproducible on Package " + mName);
+        mLogger.debug("isReproducible on Package {}", mName);
         boolean retVal = ! mBuildStandardCollection.isEmpty();
-        mLogger.info("isReproducible returned " + retVal);
+        mLogger.info("isReproducible returned {}", retVal);
         return retVal;
+    }
     /**
      * returns true if at least one of its BuildStandards has mGeneric true
      */
     boolean isGeneric()
+    {
-        mLogger.debug("isGeneric on Package " + mName);
+        mLogger.debug("isGeneric on Package {}", mName);
         boolean retVal = false;
         for (Iterator<BuildStandard> it = mBuildStandardCollection.iterator(); it.hasNext();)
+        {
             BuildStandard buildStandard = it.next();
                 retVal = true;
                 break;
+            }
+        }
-        mLogger.info("isGeneric returned " + retVal);
+        mLogger.info("isGeneric returned {}", retVal);
         return retVal;
+    }
     /**
      * Returns true if at least one of the packages build standards can be
         return false;
+    }
     /**
-     * Applies the required version number change
+     * Applies the required version number change. Will calculate mNextVersion
+     * while not changing mVersion.
+     *
      * @param releaseManager    Release Manager instance to work against
-     * @param rtag_id           Release Identifier
+     *
-     * @return 0 on success
+     * @return 0 : success
-     *         1 on cannot work with non standard versioning
+     *         1 : cannot work with non standard versioning
-     *         2 on ripple field limitations prevent a ripple build
+     *         2 : ripple field limitations prevent a ripple build
-     *         3 on Invalid Change Type
+     *         3 : Invalid Change Type
      * @exception Exception
      */
-    int applyPV(ReleaseManager releaseManager, int rtag_id) throws Exception
+    int applyPV(ReleaseManager releaseManager) throws Exception
+    {
         String logInfo = "applyPV," + mName;
         mLogger.debug("applyPV on Package " + mName);
+        //
+        //  This method used to actually perform the version change
+        //  Now it just calculates the potential value
+        //  Must not alter mVersion as it will be used if the package is not selected to be built,
+        //  but some of the code assumes that it can be.
+        //
+        String originalVersion = mVersion;
         //
         // Four scenarios, only applyPV for 3 of them
         // mDirectlyPlanned mIndirectlyPlanned mArchivalExistence mForcedRipple
         // Action
         // WIP/test build exists: true true don't care don't care applyPV
         if (!mDirectlyPlanned && mIndirectlyPlanned && !mArchivalExistence && mForcedRippleInstruction == 0)
+        {
             // the package has an mIndirectlyPlanned flag set true in daemon
             // mode because the package does not exist in an archive
             // do not apply a different package version
-            mLogger.info("applyPV. Rebuild Package " + mName);
+            mLogger.info("applyPV. Rebuild Package {}", mName);
-            releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
             mLogger.info("applyPv returned 0");
             return 0;
+        }
         // override - no longer doing a rebuild - version number change from this point on
         // Detect invalid change type
         // Flagged when package instance is created
         //
         if (mChangeType.mUnknown)
+        {
-            mLogger.info("Package Version specified on Package " + mName + "New Version:" + mVersion);
+            mLogger.info("Package Version specified on Package {} New Version: {}", mName, mVersion);
             mLogger.info("applyPv returned 3");
             return 3;
+        }
         // If we are not calculating the new package version because the user
         // has fixed the version of the package. We are given the new package version.
         if (mChangeType.mFixed)
+        {
             // mVersion is already setup
-            mVersion = mFixedVersion;
+            mNextVersion = mFixedVersion;
-            mLogger.info("Package Version specified on Package " + mName + "New Version:" + mVersion);
+            mLogger.info("Package Version specified on Package {} New Version: {}", mName,  mVersion);
-            releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
             mLogger.info("applyPv returned 0");
             return 0;
+        }
         // We need to calculate the new version number
             // Can ripple a .cots package under very controlled conditions
             // Its ends with a .patchBuild field
             // Package is marked as ripple via build number
             // Change type of Major and Minor are not allowed
             //
-            if (!mChangeType.mMajor && !mChangeType.mMinor && mRippleField.mBuild && mExtension.compareTo(".cots") == 0
+            if (!mChangeType.mMajor && !mChangeType.mMinor && mRippleField.mBuild && mExtension.compareTo(".cots") == 0 && field.length > 0)
-                    && field.length > 0)
+            {
-                // DEVI 52782
                 // allow and work with (ripple build) versions a.b.c.d....xxxx
                 // where xxxx.length > 3
                 String patchStr = field[field.length - 1];
                 int patchLen = patchStr.length();
+            }
+        }
         if (nonStandardCotsVersion.length() == 0 && patch.value < 1000 && field[2].substring(0, 1).compareTo("0") != 0)
+        {
-            mLogger.info("applyPV accomodate old style mVersion of the form 1.0.1");
+            mLogger.info("applyPV accomodate old style Version of the form 1.0.1");
             patch.value = patch.value * 1000;
+        }
         // mChangeType overrides mRippleField
         do
+            {
                 logInfo += ",CT Major";
                 if (!incrementFieldsAccordingToLimits(4, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
+                    mVersion = originalVersion;
                     return 2;
+                }
             } else if (mChangeType.mMinor)
+            {
                 logInfo += ",CT Minor";
                 if (!incrementFieldsAccordingToLimits(3, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
+                    mVersion = originalVersion;
                     return 2;
+                }
             } else if (mChangeType.mPatch)
+            {
                 logInfo += ",CT Patch";
                 if (!incrementFieldsAccordingToLimits(2, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
+                    mVersion = originalVersion;
                     return 2;
+                }
             } else
+            {
                 if (mRippleField.mMajor)
+                {
                     logInfo += ",R Major";
                     major.value++;
-                    mLogger.info("applyPV mRippleField.mMajor " + major.value);
+                    mLogger.info("applyPV mRippleField.mMajor {}", major.value);
                     minor.value = 0;
                     patch.value = 0;
                 } else if (mRippleField.mMinor)
+                {
                     logInfo += ",R Minor";
                     minor.value++;
-                    mLogger.info("applyPV mRippleField.mMinor " + minor.value);
+                    mLogger.info("applyPV mRippleField.mMinor {}", minor.value);
                     patch.value = 0;
                 } else if (mRippleField.mPatch)
+                {
                     logInfo += ",R Patch";
                     patch.value = ((patch.value / 1000) + 1) * 1000;
-                    mLogger.info("applyPV mRippleField.mPatch " + patch.value);
+                    mLogger.info("applyPV mRippleField.mPatch {}", patch.value);
                 } else if (mRippleField.mBuild)
+                {
                     logInfo += ", R Build";
                     patch.value++;
-                    mLogger.info("applyPV mRippleField.mBuild " + patch.value);
+                    mLogger.info("applyPV mRippleField.mBuild {}", patch.value);
                 } else
+                {
                     if (!incrementFieldsAccordingToLimits(1, major, minor, patch))
+                    {
                         mLogger.info("applyPv returned 2");
+                        mVersion = originalVersion;
                         return 2;
+                    }
+                }
+            }
+            {
                 mVersion += "0";
+            }
             mVersion += String.valueOf(patch.value);
-        } while (exists(releaseManager, rtag_id));
+        } while (exists(releaseManager));
-        logInfo += ", Claim:" + mVersion;
+        logInfo += ", Next Version:" + mVersion;
-        releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
         mLogger.error(logInfo);
         mLogger.info("applyPv returned 0");
+        mNextVersion = mVersion;
+        mVersion = originalVersion;
         return 0;
+    }
     /**
      * increments fields according to mRippleField.mLimit if necessary will
         return retVal;
+    }
     /**
-     * Check if a Package Version exists in dpkg_archive or the Release Manager Database
+     * Check if a specified Version of the package exists in dpkg_archive or the Release Manager Database
+     *
      * @param releaseManager Release Manager Instance
-     * @param rtag_id        Release Tag Identifier
+     *
      * @return True if the Package Version exists within the Release Manager Database
      * @exception Exception
      */
-    private boolean exists(ReleaseManager releaseManager, int rtag_id) throws Exception
+    private boolean exists(ReleaseManager releaseManager) throws Exception
+    {
         mLogger.debug("exists on Package " + mName + " version " + mVersion + " extension " + mExtension);
         boolean retVal = false;
         if (!releaseManager.mUseDatabase)
+    }
     /**
      * Adds email to mBuildFailureEmailCollection.
      * Do not worry about multiple entries. These will be handled when the data is extracted
-     * @param   email   - Email address
+     * @param   email   - Email address. Null is allowed and will not be added
      */
     public void addEmail(String email)
+    {
-        mBuildFailureEmailCollection.add(email);
-    }
-    /**
-     * Transfer the Test Build Email information to the packages email list
-     */
-    void setTestEmail()
-    {
-        mBuildFailureEmailCollection.clear();
-        addEmail(mTestBuildEmail);
+        if (email != null)
-    }
-    /**
-     * Transfer the Test Build Dependency information to the packages dependency collection
-     */
-    void setTestDependencyCollection()
-    {
-        // does not worry about mPackageDendencyCollection by design
-        mDependencyCollection.clear();
-        for (Iterator<String> it = mTestBuildDependencyCollection.iterator(); it.hasNext();)
+        {
-            String dependency = it.next();
-            mDependencyCollection.add(dependency);
-        }
-    }
-    /**
-     * Transfer the Test Build Build Standard information to the packages build standard collection
-     */
-    void setTestBuildStandardCollection()
-    {
-        mBuildStandardCollection.clear();
-        for (Iterator<BuildStandard> it = mTestBuildStandardCollection.iterator(); it.hasNext();)
-        {
-            BuildStandard buildStandard = it.next();
-            mBuildStandardCollection.add(buildStandard);
+            mBuildFailureEmailCollection.add(email);
+        }
+    }
     /**
      * End of Processing for a Test Build
         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);
+        mLogger.debug("hasCircularDependency: {}", mAlias);
-        boolean retVal = detectCircularDependency(mAlias, ripEng, null);
+        boolean retVal = detectCircularDependency(mAlias, packageCollection, null);
-        mLogger.info("hasCircularDependency returned " + retVal);
+        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;
             mCheckedCircularDependency = true;
+        }
         // return the persisted circular dependency outcome
         retVal = mHasCircularDependency;
-        mLogger.info("detectCircularDependency 2 returned " + retVal);
+        mLogger.info("detectCircularDependency 2 returned {}", retVal);
         return retVal;
+    }
+    /** Set the sequence of all packages in the list
+     *  Used so that the Unit Tests function can preserve the basic ordering of the list
+     */
+    public static void setSequence(ArrayList<Package> al)
+    {
+        int seq = 1;
+        for (Iterator<Package> it = al.iterator(); it.hasNext(); )
+        {
+            Package p = it.next();
+            p.mSeqId = seq++;
+        }
+    }
+    /** Reset the processed flag on a collection of packages
+     *
+     */
+    public static void resetProcessed (ArrayList<Package> al)
+    {
+        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;
+        }
+    }
+    /** Comparator for sorting package collections by mSeqId
+     *  Used to preserve order for unit testing
+     */
+    public static final Comparator<Package> SeqComparator = 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.mSeqId - p2.mSeqId;
+        }
+    };
     /**
      * 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
      */
             mUnknown = true;
+        }
+    }
+    /**
+     *  Add a package dependency
+     *  UTF Use
+     *  @param p - The package to add as a dependent
+     *  @return - The current package to allow chaining of calls
+     */
+    public Package addDependency(Package p) {
+        mDependencyCollection.add(p.mAlias);
+        mDependencyIDCollection.add(p.mId);
+        return this;
+    }
+    /** Clear the packages list of dependencies
+     *  UTF use
+     *  @return - The current package to allow chaining of calls
+     */
+    public Package resetDependencies() {
+        mDependencyCollection.clear();
+        mDependencyIDCollection.clear();
+        return this;
+    }
+}

Subversion Repositories DevTools

(root)/buildtool/trunk/src/main/java/com/erggroup/buildtool/ripple/Package.java – Rev 7046 → 7082