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

      * <br>  -7 Pegged or SDK Imported package not in dpkg_archive
      * <br>  -8 Pegged or SDK Imported package
      * <br>  -9 Rejected Daemon Instruction
      * <br>  -10 UnBuildable Package not in dpkg_archive
      * <br>  -11 Marked as RippleStop
+     * <br>  -12 Cannot calc next version number
+     *
      */
     int mBuildFile = 0;
     /** Retained reason the package will not be built
      */
     public boolean mIsProcessed = false;
     /**
      * Constructor
-     * Used to create planned packages. In these packages the change_type is significant
+     * Used to create planned packages (WIP). In these packages the change_type is significant
+     *
-     * @param pkg_id	   Package Name Identifier
+     * @param pkgId	   Package Name Identifier
-     * @param pv_id        Package Version Id
+     * @param pvId        Package Version Id
-     * @param pkg_name     Package Name
+     * @param pkgName     Package Name
-     * @param pkg_version  Package Version
+     * @param pkgVersion  Package Version
-     * @param v_ext        Package Suffix
+     * @param vExt        Package Suffix
      * @param alias        Package Alias
-     * @param pkg_vcs_tag  Vcs Tag
+     * @param pkgVcsTag  Vcs Tag
-     * @param ripple_field Ripple Field
+     * @param rippleField Ripple Field
-     * @param change_type  Change Type
+     * @param changeType  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, char ripple_field, char change_type)
+    public Package(int pkgId, int pvId, String pkgName, String pkgVersion, String vExt, String alias, String pkgVcsTag, char rippleField, char changeType)
     {
-        mLogger.debug("Package 1: pv_id " + pv_id + " pkg_name " + pkg_name + " v_ext " + v_ext + " alias " + alias
+        mLogger.debug("Package 1: pv_id {} pkg_name {} v_ext {} alias {} pkg_vcs_tag {} ripple_field {} change_type {}", pvId, pkgName,vExt,alias, pkgVcsTag, rippleField, changeType);
-                + " pkg_vcs_tag " + pkg_vcs_tag + " change_type " + change_type);
-        mId = pv_id;
+        mId = pvId;
-        mName = pkg_name;
+        mName = pkgName;
-        mPid = pkg_id;
+        mPid = pkgId;
         mVersion = "0.0.0000";
-        mExtension = v_ext;
+        mExtension = vExt;
         mAlias = alias;
-        mVcsTag = pkg_vcs_tag;
+        mVcsTag = pkgVcsTag;
         // Remove the package suffix from package_version to create the fixed version number
-        mFixedVersion = pkg_version;
+        mFixedVersion = pkgVersion;
         mFixedVersion = mFixedVersion.substring(0, mFixedVersion.length() - mExtension.length());
         // a ripple_field of 'L' indicates this package has limited version numbering
-        if (change_type == 'M') {
+        if (changeType == 'M') {
-            mChangeType.setMajor(ripple_field == 'L' ? true : false);
+            mChangeType.setMajor(rippleField == 'L' ? true : false);
-        } else if (change_type == 'N') {
+        } else if (changeType == 'N') {
-            mChangeType.setMinor(ripple_field == 'L' ? true : false);
+            mChangeType.setMinor(rippleField == 'L' ? true : false);
-        } else if (change_type == 'P') {
+        } else if (changeType == 'P') {
-            mChangeType.setPatch(ripple_field == 'L' ? true : false);
+            mChangeType.setPatch(rippleField == 'L' ? true : false);
-        } else if (change_type == 'F') {
+        } else if (changeType == 'F') {
             mChangeType.setFixed();
         } else {
             mChangeType.setUnknown();
+        }
     /**
      * Constructor
      * Used to create existing packages, in these packages the ripple_field is significant
+     *
-     * @param pkg_id	   Package Name Identifier
+     * @param pkgId	   Package Name Identifier
-     * @param pv_id        Package Version Id
+     * @param pvId        Package Version Id
-     * @param pkg_name     Package Name
+     * @param pkgName     Package Name
-     * @param pkg_version  Package Version
+     * @param pkgVersion  Package Version
-     * @param v_ext        Package Suffix
+     * @param vExt        Package Suffix
      * @param alias        Package Alias
-     * @param pkg_vcs_tag  Vcs Tag
+     * @param pkgVcsTag  Vcs Tag
-     * @param ripple_field Ripple Field
+     * @param rippleField 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, char ripple_field)
+    public Package(int pkgId,int pvId, String pkgName, String pkgVersion, String vExt, String alias, String pkgVcsTag, char rippleField)
+    {
-        mLogger.debug("Package 2: pv_id " + pv_id + " pkg_name " + pkg_name + " pkg_version " + pkg_version + " v_ext "
+        mLogger.debug("Package 2: pv_id {} pkg_name {} v_ext {} alias {} pkg_vcs_tag {} ripple_field {}", pvId, pkgName,vExt,alias, pkgVcsTag, rippleField);
-                + v_ext + " alias " + alias + " pkg_vcs_tag " + pkg_vcs_tag + " ripple_field " + ripple_field);
-        mId = pv_id;
+        mId = pvId;
-        mName = pkg_name;
+        mName = pkgName;
-        mPid = pkg_id;
+        mPid = pkgId;
-        mVersion = pkg_version;
+        mVersion = pkgVersion;
-        int endindex = mVersion.length() - v_ext.length();
+        int endindex = mVersion.length() - vExt.length();
         if (endindex > 0)
+        {
             mVersion = mVersion.substring(0, endindex);
+        }
-        mExtension = v_ext;
+        mExtension = vExt;
         mAlias = alias;
-        mVcsTag = pkg_vcs_tag;
+        mVcsTag = pkgVcsTag;
         // setBuild is the default
-        if (ripple_field == 'M') {
+        if (rippleField == 'M') {
             mRippleField.setMajor();
-        } else if (ripple_field == 'm') {
+        } else if (rippleField == 'm') {
             mRippleField.setMinor();
-        } else if (ripple_field == 'p') {
+        } else if (rippleField == 'p') {
             mRippleField.setPatch();
-        } else if (ripple_field == 'L') {
+        } else if (rippleField == 'L') {
             mRippleField.setLimit();
+        }
+    }
     /**
      */
     int applyPV(ReleaseManager releaseManager) throws Exception
+    {
         String logInfo = "applyPV," + mName;
+        String changeType = "";
-        mLogger.debug("applyPV on Package " + mName);
+        mLogger.error("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,
         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.error("applyPV. Rebuild Package {}", mName);
             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 {} New Version: {}", mName, mVersion);
+            mLogger.error("Package Version unknown on Package {} Version: {}", mName, mVersion);
             mLogger.info("applyPv returned 3");
             return 3;
+        }
         // If we are not calculating the new package version because the user
         if (mChangeType.mFixed)
+        {
             // mVersion is already setup
             mNextVersion = mFixedVersion;
-            mLogger.info("Package Version specified on Package {} New Version: {}", mName,  mVersion);
+            mLogger.error("Package Version specified on Package {} New Version: {}", mName,  mNextVersion);
             mLogger.info("applyPv returned 0");
             return 0;
+        }
         // We need to calculate the new version number
         // mChangeType overrides mRippleField
         do
+        {
             if (mChangeType.mMajor)
+            {
-                logInfo += ",CT Major";
+                changeType = ",CT Major";
                 if (!incrementFieldsAccordingToLimits(4, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
                     mVersion = originalVersion;
                     return 2;
+                }
             } else if (mChangeType.mMinor)
+            {
-                logInfo += ",CT Minor";
+                changeType = ",CT Minor";
                 if (!incrementFieldsAccordingToLimits(3, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
                     mVersion = originalVersion;
                     return 2;
+                }
             } else if (mChangeType.mPatch)
+            {
-                logInfo += ",CT Patch";
+                changeType = ",CT Patch";
                 if (!incrementFieldsAccordingToLimits(2, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
                     mVersion = originalVersion;
                     return 2;
+                }
             } else
+            {
                 if (mRippleField.mMajor)
+                {
-                    logInfo += ",R Major";
+                    changeType = ",R Major";
                     major.value++;
                     mLogger.info("applyPV mRippleField.mMajor {}", major.value);
                     minor.value = 0;
                     patch.value = 0;
                 } else if (mRippleField.mMinor)
+                {
-                    logInfo += ",R Minor";
+                    changeType = ",R Minor";
                     minor.value++;
                     mLogger.info("applyPV mRippleField.mMinor {}", minor.value);
                     patch.value = 0;
                 } else if (mRippleField.mPatch)
+                {
-                    logInfo += ",R Patch";
+                    changeType = ",R Patch";
                     patch.value = ((patch.value / 1000) + 1) * 1000;
                     mLogger.info("applyPV mRippleField.mPatch {}", patch.value);
                 } else if (mRippleField.mBuild)
+                {
-                    logInfo += ", R Build";
+                    changeType = ", R Build";
                     patch.value++;
                     mLogger.info("applyPV mRippleField.mBuild {}", patch.value);
                 } else
+                {
                     if (!incrementFieldsAccordingToLimits(1, major, minor, patch))
+            }
             mVersion += String.valueOf(patch.value);
         } while (exists(releaseManager));
-        logInfo += ", Next Version:" + mVersion;
+        logInfo += changeType + ", Next Version:" + mVersion;
         mLogger.error(logInfo);
         mLogger.info("applyPv returned 0");
         mNextVersion = mVersion;
         mVersion = originalVersion;
         return 0;

Subversion Repositories DevTools

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