GiGrouperVersion

/*******************************************************************************
 * Copyright 2012 Internet2
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
/*
 * @author mchyzer
 * $Id: GrouperVersion.java,v 1.9 2009-11-18 17:03:50 mchyzer Exp $
 */
package edu.internet2.middleware.grouperInstaller;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import edu.internet2.middleware.grouperInstaller.util.GrouperInstallerUtils;


/**
 * keep track of which version grouper is.  Update this file (the GROUPER_VERSION constant) before each
 * non-release-candidate release
 */
public class GiGrouperVersion {

  /**
   * return the parsed and tostring version of this version string (consistent),
   * or null if nothing passed in
   * @param versionString
   * @return the version string
   */
  public static String stringValueOrNull(String versionString) {
    if (GrouperInstallerUtils.isBlank(versionString)) {
      return null;
    }
    return valueOfIgnoreCase(versionString, true).toString();
  }

  /**
   * @see Object#equals(Object)
   */
  @Override
  public boolean equals(Object obj) {
    if (!(obj instanceof GiGrouperVersion)) {
      return false;
    }
    GiGrouperVersion../edu/internet2/middleware/grouperInstaller/GiGrouperVersion.html#GiGrouperVersion">GiGrouperVersion other = (GiGrouperVersion)obj;
    if (this.build != other.build) {
      return false;
    }
    if (this.major != other.major) {
      return false;
    }
    if (this.minor != other.minor) {
      return false;
    }
    if (!GrouperInstallerUtils.equals(this.rc, other.rc)) {
      return false;
    }
    return true;
  }


  /**
   * @see java.lang.Object#hashCode()
   */
  @Override
  public int hashCode() {

    return ("" + this.major + "" + this.minor + "" + this.build + "" + this.rc).hashCode();

  }


  /**
   *
   * @see java.lang.Object#toString()
   */
  @Override
  public String toString() {
    String result = this.major + "." + this.minor + "." + this.build;
    if (this.rc != null) {
      result+= "rc" + this.rc;
    }
    return result;
  }

  /**
   * se we dont have to keep constructing this
   */
  private static GiGrouperVersion currentVersion = null;

  /**
   * current grouper version
   * @return current grouper version
   */
  public static GiGrouperVersion currentVersion() {
    if (currentVersion == null) {
      currentVersion = valueOfIgnoreCase(GrouperInstallerUtils.grouperInstallerVersion());
    }
    return currentVersion;
  }


  /** major number */
  private int major;

  /** minor number */
  private int minor;

  /** build number */
  private int build;

  /** rc number (release cnadidate) */
  private Integer rc;

  /** keep a map of max size 1000 */
  private static Map<String, GiGrouperVersion> versionCache = new HashMap<String, GiGrouperVersion>();

  /**
   * convert string to version like an enum would
   *
   * @param string cannot be blank
   * @return the enum or null or exception if not found
   */
  public static GiGrouperVersion valueOfIgnoreCase(String string) {
    return valueOfIgnoreCase(string, true);
  }

  /**
   * convert string to version like an enum would
   *
   * @param string
   * @param exceptionOnNull will not allow null or blank entries
   * @return the enum or null or exception if not found
   */
  public static GiGrouperVersion valueOfIgnoreCase(String string, boolean exceptionOnNull) {

    if (GrouperInstallerUtils.isBlank(string)) {
      if (exceptionOnNull) {
        throw new RuntimeException("Not expecting a blank string for version");
      }
      return null;
    }

    //see if in cache
    GiGrouperVersion grouperVersion = versionCache.get(string);
    if (grouperVersion != null) {
      return grouperVersion;
    }

    grouperVersion = new GiGrouperVersion(string);

    //dont cause a memory leak
    if (versionCache.size() < 1000) {
      versionCache.put(string, grouperVersion);
    }
    return grouperVersion;
  }

  /**
   * private constructor
   * @param versionString
   */
  public GiGrouperVersion(String versionString) {
    Matcher grouperMatcher = shortPattern.matcher(versionString);

    // 1.2
    if (!grouperMatcher.matches()) {

      grouperMatcher = pattern.matcher(versionString);

      // 1.2.3
      if (!grouperMatcher.matches()) {


        grouperMatcher = rcPattern.matcher(versionString);

        // 1.2.3rc4
        if (!grouperMatcher.matches()) {


          throw new RuntimeException("Invalid version: " + versionString
              + ", expecting something like: 1.1 or 1.2.3 or 1.2.3rc4");
        }
        this.rc = GrouperInstallerUtils.intValue(grouperMatcher.group(4));
      }
      this.build = GrouperInstallerUtils.intValue(grouperMatcher.group(3));

    }
    //get the grouper versions
    this.major = GrouperInstallerUtils.intValue(grouperMatcher.group(1));
    this.minor = GrouperInstallerUtils.intValue(grouperMatcher.group(2));

  }

  /**
   * see if the grouper version is greater than or equal to a certain version
   * @param version
   * @return true if the grouper version is greater than or equal to a certain version
   */
  public static boolean grouperVersionGreaterOrEqual(String version) {
    return _grouperVersionGreaterOrEqualHelper(currentVersion().toString(), version);
  }

  /**
   * see if the grouper version is greater than or equal to a certain version
   * @param version
   * @return true if the grouper version is greater than or equal to a certain version
   */
  public boolean greaterOrEqualToArg(String version) {
    return this.thisGreaterThanArgument(new GiGrouperVersion(version), true);
  }

  /**
   * see if this version is less than the argument one
   * @param other
   * @param orEqual
   * @return true if less than, false if equal or greater
   */
  public boolean lessThanArg(GiGrouperVersion other, boolean orEqual) {
    //switch these around.  if a < b, then b > a
    return other.thisGreaterThanArgument(this, orEqual);
  }

  /**
   * see if this version is less than the argument one, only considering major and minor version
   * @param other
   * @param orEqual
   * @return true if less than, false if equal or greater
   */
  public boolean lessThanMajorMinorArg(GiGrouperVersion other, boolean orEqual) {

    GiGrouperVersion thisMajorMinor = valueOfIgnoreCase(this.major + "." + this.minor + ".0");
    GiGrouperVersion otherMajorMinor = valueOfIgnoreCase(other.major + "." + other.minor + ".0");

    return thisMajorMinor.lessThanArg(otherMajorMinor, orEqual);

  }

  /**
   * see if this version is less than the argument one
   * @param other
   * @return true if less than, false if equal or greater
   */
  public boolean lessThanArg(GiGrouperVersion other) {
    return this.lessThanArg(other, false);
  }

  /**
   * see if the grouper version is greater than or equal to a certain version
   * @param version
   * @return true if the grouper version is greater than or equal to a certain version
   */
  public boolean greaterOrEqualToArg(GiGrouperVersion version) {
    return this.thisGreaterThanArgument(version, true);
  }

  /**
   * <pre>
   * start of string, optional v or V, first digit, period or underscore, second digit, period or underscore, third digit, end of string
   * parens are for capturing
   * ^(\\d+)\\.(\\d+)\\.(\\d+)$
   * </pre>
   */
  private static Pattern pattern = Pattern.compile("^[vV]?(\\d+)[\\._](\\d+)[\\._](\\d+)$");

  /**
   * <pre>
   * start of string, optional v or V, first digit, period or underscore, second digit, period or underscore, third digit, end of string
   * parens are for capturing
   * ^(\\d+)\\.(\\d+)$
   * </pre>
   */
  private static Pattern shortPattern = Pattern.compile("^[vV]?(\\d+)[\\._](\\d+)$");

  /**
   * <pre>
   * start of string, optional v or V, first digit, period or underscope, second digit, period or underscore, third digit,
   * period, rc, 4th digit, end of string
   * parens are for capturing
   * ^(\\d+)\\.(\\d+)\\.(\\d+)$
   * </pre>
   */
  private static Pattern rcPattern = Pattern.compile("^[vV]?(\\d+)[\\._](\\d+)[\\._](\\d+)\\-?rc(\\d+)$");

  /**
   * helper method for unit testing
   * @param grouperVersion
   * @param anotherVersion
   * @return true if grouper is greater
   */
  public static boolean _grouperVersionGreaterOrEqualHelper(String grouperVersion, String anotherVersion) {
    GiGrouperVersioner/GiGrouperVersion.html#GiGrouperVersion">GiGrouperVersion grouper = new GiGrouperVersion(grouperVersion);
    GiGrouperVersioner/GiGrouperVersion.html#GiGrouperVersion">GiGrouperVersion another = new GiGrouperVersion(anotherVersion);
    //for grouper version to be greater or equal
    return grouper.thisGreaterThanArgument(another, true);
  }

  /**
   * see if this version is greater than or equal the argument
   * @param anotherVersion
   * @param orEqual if true then count equals as a true
   * @return true if this is less
   */
  private boolean thisGreaterThanArgument(GiGrouperVersion anotherVersion, boolean orEqual) {
    //compare, first with major, minor, then build
    if (this.major > anotherVersion.major) {
      return true;
    } else if (this.major < anotherVersion.major) {
      return false;
    }
    if (this.minor > anotherVersion.minor) {
      return true;
    } else if (this.minor < anotherVersion.minor) {
      return false;
    }
    //note its greater or equal
    if (this.build > anotherVersion.build) {
      return true;
    } else if (this.build < anotherVersion.build) {
      return false;
    }
    if (GrouperInstallerUtils.equals(this.rc, anotherVersion.rc)) {
      return orEqual;
    }
    //not having a release candidate version is higher than having one
    if (this.rc == null) {
      return true;
    }
    if (anotherVersion.rc == null) {
      return false;
    }
    return this.rc > anotherVersion.rc;
  }
}