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

    * used for querying package version existence in the database in daemon mode
    * @attribute
    */
   int mPid;
+  /**maximum major number supported for determining ripple number
+   * @attribute
+   */
+  int mMajorLimit;
+  /**maximum minor number supported for determining ripple number
+   * @attribute
+   */
+  int mMinorLimit;
+  /**maximum patch number supported for determining ripple number
+   * @attribute
+   */
+  int mPatchLimit;
+  /**maximum build number number supported for determining ripple number
+   * @attribute
+   */
+  int mBuildLimit;
   /**Logger
    * @attribute
    */
   private static final Logger mLogger = Logger.getLogger(Package.class);
     mExtension = v_ext;
     mAlias = alias;
     mLabel = pkg_label;
     mLocation = src_path;
+    // setBuild is the default
     if (ripple_field == 'M')
+    {
       mRippleField.setMajor();
+    }
     else if (ripple_field == 'm')
+    }
     else if (ripple_field == 'p')
+    {
       mRippleField.setPatch();
+    }
+    else if (ripple_field == 'L')
+    {
+      mRippleField.setLimit();
+    }
+  }
   /**constructor
    */
   Package()
     mAlias = "null";
     mLabel = "null";
     mLocation = "null";
+  }
+  /**constructor for unit test purposes
+  */
+  public Package(ReleaseManager rm, String version, int majorLimit, int minorLimit, int patchLimit, int buildNumberLimit)
+  {
+    mId = -1;
+    mRippleField.setLimit();
+    mVersion = version;
+    mMajorLimit = majorLimit;
+    mMinorLimit = minorLimit;
+    mPatchLimit = patchLimit;
+    mBuildLimit = buildNumberLimit;
+    try
+    {
+      mId = applyPV( rm, 0 );
+    }
+    catch(Exception e)
+    {
+    }
+  }
+  /**accessor for unit test purposes
+   */
+  public int getId()
+  {
+    return mId;
+  }
+  /**accessor for unit test purposes
+   */
+  public String getVersion()
+  {
+    return mVersion;
+  }
   /**returns true if mBuildStandardCollection is not empty
    */
   boolean isReproducible()
+  {
     mLogger.debug("isReproducible on Package " + mName);
     mLogger.info("isGeneric returned " + retVal);
     return retVal;
+  }
   /**applies the required version number change
+   * returns 0 on success
+   *         1 on cannot work with non standard versioning
+   *         2 on ripple field limitations prevent a ripple build
    */
-  void applyPV(ReleaseManager releaseManager, int rtag_id) throws Exception
+  int applyPV(ReleaseManager releaseManager, int rtag_id) throws Exception
+  {
     mLogger.debug("applyPV on Package " + mName);
     // three scenarios, only applyPV for 2 of them
     // WIP exists:                      mDirectlyPlanned == true;   mIndirectlyPlanned == true; mArchivalExistence don't care - applyPV
     // Package version is out of date:  mDirectlyPlanned == false;  mIndirectlyPlanned == true; mArchivalExistence == true    - applyPV
+    {
       // 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 !mDirectlyPlanned && mIndirectlyPlanned && !mArchivalExistence on Package " + mName);
       releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
+      mLogger.info("applyPv returned 0");
-      return;
+      return 0;
+    }
     int major = 0;
     int minor = 0;
     int patch = 1000;
+    }
     else
+    {
       // cannot work with non standard versioning
       mLogger.error("applyPV cannot work with non standard versioning");
+      mLogger.info("applyPv returned 1");
-      return;
+      return 1;
+    }
     if ( patch < 1000 && field[2].substring(0, 1).compareTo("0") != 0 )
+    {
       mLogger.info("applyPV accomodate old style mVersion of the form 1.0.1");
+          {
             patch++;
           } while ( ( patch / 1000 ) * 1000 != patch );
           mLogger.info("applyPV mRippleField.mPatch " + patch);
+        }
-        else
+        else if ( mRippleField.mBuild )
+        {
           patch++;
-          mLogger.info("applyPV ripple field default " + patch);
+          mLogger.info("applyPV mRippleField.mBuild " + patch);
+        }
+        else
+        {
+          // increment fields according to limits
+          boolean changeOccurred = false;
+          boolean incrementField = true;
+          if ( mBuildLimit != 0 )
+          {
+            // increment or reset the patch build number
+            if ( patch < mBuildLimit )
+            {
+              // can increment the patch build number
+              patch++;
+              mLogger.info("applyPv mRippleField.mLimit build number " + patch);
+              changeOccurred = true;
+              incrementField = false;
+            }
+            else
+            {
+              if ( mPatchLimit == 0 )
+              {
+                // reset the patch number and patch build number
+                patch = 0;
+              }
+            }
+          }
+          if ( mPatchLimit != 0 && incrementField )
+          {
+            // increment or reset the patch number
+            if ( ( patch / 1000 ) < mPatchLimit )
+            {
+              do
+              {
+                patch++;
+              } while ( ( patch / 1000 ) * 1000 != patch );
+              mLogger.info("applyPv mRippleField.mLimit patch " + patch);
+              changeOccurred = true;
+              incrementField = false;
+            }
+            else
+            {
+              // reset the patch number and patch build number
+              patch = 0;
+            }
+          }
+          if ( mMinorLimit != 0 && incrementField )
+          {
+            // increment or reset the minor number
+            if ( minor < mMinorLimit )
+            {
+              minor++;
+              mLogger.info("applyPv mRippleField.mLimit minor " + minor);
+              changeOccurred = true;
+              incrementField = false;
+            }
+            else
+            {
+              // reset the minor number
+              minor = 0;
+            }
+          }
+          if ( mMajorLimit != 0 && incrementField )
+          {
+            // increment or reset the major number
+            if ( major < mMajorLimit )
+            {
+              // increment the major number
+              changeOccurred = true;
+              major++;
+              mLogger.info("applyPv mRippleField.mLimit major " + major);
+            }
+          }
+          if ( !changeOccurred )
+          {
+            // unable to increment a field due to field limitations
+            mLogger.error("applyPV ripple field limitations prevent a ripple build");
+            mLogger.info("applyPv returned 2");
+            return 2;
+          }
+        }
+      }
       mVersion = String.valueOf(major) + "." + String.valueOf(minor) + ".";
       mVersion += String.valueOf(patch);
     } while ( exists(releaseManager, rtag_id) );
     releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
+    mLogger.info("applyPv returned 0");
+    return 0;
+  }
   /**returns true if the version exists in the dpkg_archive, deploy_archive or release manager database
    * claims the version in the release manager database
    */
      * when true indicates the build number will be incremented
      * @attribute
      */
     private boolean mBuild = true;
+    /**in terms of the mChangeType Package field,
+     * always false, does not apply
+     * in terms of the mRippleField Package field,
+     * when true indicates the major, minor, patch and build number will be incremented according to field limits
+     * @attribute
+     */
+    private boolean mLimit = false;
     /**constructor
      */
     private VersionNumberingStandard()
+    {
       mLogger.debug("VersionNumberingStandard");
+    }
-    /**sets mBuild true, mMajor false, mMinor false, mPatch false
+    /**sets mBuild true, mMajor false, mMinor false, mPatch false, mLimit false
      */
     void setBuild()
+    {
       mLogger.debug("setBuild");
       mBuild = true;
       mMajor = false;
       mMinor = false;
       mPatch = false;
+      mLimit = false;
+    }
-    /**sets mBuild false, mMajor true, mMinor false, mPatch false
+    /**sets mBuild false, mMajor true, mMinor false, mPatch false, mLimit false
      */
     void setMajor()
+    {
       mLogger.debug("setMajor");
       mBuild = false;
       mMajor = true;
       mMinor = false;
       mPatch = false;
+      mLimit = false;
+    }
-    /**sets mBuild false, mMajor false, mMinor true, mPatch false
+    /**sets mBuild false, mMajor false, mMinor true, mPatch false, mLimit false
      */
     void setMinor()
+    {
       mLogger.debug("setMinor");
       mBuild = false;
       mMajor = false;
       mMinor = true;
       mPatch = false;
+      mLimit = false;
+    }
-    /**sets mBuild false, mMajor false, mMinor false, mPatch true
+    /**sets mBuild false, mMajor false, mMinor false, mPatch true, mLimit false
      */
     void setPatch()
+    {
       mLogger.debug("setPatch");
       mBuild = false;
       mMajor = false;
       mMinor = false;
       mPatch = true;
+      mLimit = false;
+    }
+    /**sets mBuild false, mMajor false, mMinor false, mPatch false, mLimit true
+     */
+    void setLimit()
+    {
+      mLogger.debug("setPatch");
+      mBuild = false;
+      mMajor = false;
+      mMinor = false;
+      mPatch = false;
+      mLimit = true;
+    }
+  }
+}

Subversion Repositories DevTools

(root)/buildtool/trunk/src/generated/com/erggroup/buildtool/ripple/Package.java @ 884 – Rev 868 → 874