From 959d6d83ec26152343d538287c02eeebf0dcf238 Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Fri, 31 May 2013 06:17:57 +0200 Subject: Enhance VersionNumber*: Use only RegExp and cache default (no wrapped whitespace tokenizer); String match: Store end-of-match and flag defined components. --- src/java/com/jogamp/common/util/VersionNumber.java | 183 ++++++++++++++++++--- 1 file changed, 159 insertions(+), 24 deletions(-) (limited to 'src/java/com/jogamp/common/util/VersionNumber.java') diff --git a/src/java/com/jogamp/common/util/VersionNumber.java b/src/java/com/jogamp/common/util/VersionNumber.java index db40a90..b1d8963 100644 --- a/src/java/com/jogamp/common/util/VersionNumber.java +++ b/src/java/com/jogamp/common/util/VersionNumber.java @@ -28,67 +28,202 @@ package com.jogamp.common.util; -import java.util.StringTokenizer; import java.util.regex.Matcher; /** * Simple version number class containing a version number * either being {@link #VersionNumber(int, int, int) defined explicit} * or {@link #VersionNumber(String, String) derived from a string}. + *

+ * For the latter case, you can query whether a component has been defined explicitly by the given versionString, + * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}. + *

+ *

+ * The state whether a component is defined explicitly is not considered + * in the {@link #hashCode()}, {@link #equals(Object)} or {@link #compareTo(Object)} methods, + * since the version number itself is treated regardless. + *

*/ public class VersionNumber implements Comparable { - /** A {@link #isZero() zero} version instance. */ - public static final VersionNumber zeroVersion = new VersionNumber(0, 0, 0); + /** + * A {@link #isZero() zero} version instance, w/o any component defined explicitly. + * @see #hasMajor() + * @see #hasMinor() + * @see #hasSub() + */ + public static final VersionNumber zeroVersion = new VersionNumber(0, 0, 0, -1, (short)0); + + /** + * Returns the {@link java.util.regex.Pattern pattern} + * with Perl regular expression: + * 
+     *   "\\D*(\\d+)[^\\"+delim+"\\s]*(?:\\"+delim+"\\D*(\\d+)[^\\"+delim+"\\s]*(?:\\"+delim+"\\D*(\\d+))?)?"
+     *
+ *

+ *

+ * A whitespace within the version number will end the parser. + *

+ *

+ * Capture groups represent the major (1), optional minor (2) and optional sub version number (3) component in this order. + *

+ *

+ * Each capture group ignores any leading non-digit and uses only contiguous digits, i.e. ignores pending non-digits. + *

+ * @param delim the delimiter, e.g. "." + */ + public static java.util.regex.Pattern getVersionNumberPattern(String delim) { + return java.util.regex.Pattern.compile("\\D*(\\d+)[^\\"+delim+"\\s]*(?:\\"+delim+"\\D*(\\d+)[^\\"+delim+"\\s]*(?:\\"+delim+"\\D*(\\d+))?)?"); + } + + /** + * Returns the default {@link java.util.regex.Pattern pattern} using {@link #getVersionNumberPattern(String)} + * with delimiter ".". + *

+ * Instance is cached. + *

+ */ + public static java.util.regex.Pattern getDefaultVersionNumberPattern() { + if( null == defPattern ) { // volatile dbl-checked-locking OK + synchronized( VersionNumber.class ) { + if( null == defPattern ) { + defPattern = getVersionNumberPattern("."); + } + } + } + return defPattern; + } + private static volatile java.util.regex.Pattern defPattern = null; + + protected final int major, minor, sub, strEnd; - protected final int major, minor, sub; + protected final short state; + protected final static short HAS_MAJOR = 1 << 0 ; + protected final static short HAS_MINOR = 1 << 1 ; + protected final static short HAS_SUB = 1 << 2 ; - /** Explicit version number instantiation. */ - public VersionNumber(int majorRev, int minorRev, int subMinorRev) { + protected VersionNumber(int majorRev, int minorRev, int subMinorRev, int _strEnd, short _state) { major = majorRev; minor = minorRev; sub = subMinorRev; + strEnd = _strEnd; + state = _state; + } + + /** + * Explicit version number instantiation, with all components defined explicitly. + * @see #hasMajor() + * @see #hasMinor() + * @see #hasSub() + */ + public VersionNumber(int majorRev, int minorRev, int subMinorRev) { + this(majorRev, minorRev, subMinorRev, -1, (short)(HAS_MAJOR | HAS_MINOR | HAS_SUB)); } /** * String derived version number instantiation. *

- * Parser first tokenizes the input versionString w/ given delimiter. - *

+ * Utilizing the default {@link java.util.regex.Pattern pattern} parser with delimiter ".", see {@link #getDefaultVersionNumberPattern()}. + *

*

- * Tokens represent the major, minor and sub version number component in this order. + * You can query whether a component has been defined explicitly by the given versionString, + * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}. *

+ * @param versionString should be given as [MAJOR[.MINOR[.SUB]]] + * + * @see #hasMajor() + * @see #hasMinor() + * @see #hasSub() + */ + public VersionNumber(final String versionString) { + this(versionString, getDefaultVersionNumberPattern()); + } + + /** + * String derived version number instantiation. + *

+ * Utilizing {@link java.util.regex.Pattern pattern} parser created via {@link #getVersionNumberPattern(String)}. + *

*

- * For each token it ignores any leading non-digit and uses only contiguous digits, i.e. ignores pending non-digits. + * You can query whether a component has been defined explicitly by the given versionString, + * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}. *

* @param versionString should be given as [MAJOR[.MINOR[.SUB]]] * @param delim the delimiter, e.g. "." + * + * @see #hasMajor() + * @see #hasMinor() + * @see #hasSub() */ - public VersionNumber(String versionString, String delim) { - // group1: \D* == leading non digits, optional - // group2: \d* == digits - // group3: .* == any pending chars, optional - final java.util.regex.Pattern nonDigitsCutOff = java.util.regex.Pattern.compile("(\\D*)(\\d*)(.*)"); - final StringTokenizer tok = new StringTokenizer(versionString, delim); + public VersionNumber(final String versionString, final String delim) { + this(versionString, getVersionNumberPattern(delim)); + } + + /** + * String derived version number instantiation. + *

+ * You can query whether a component has been defined explicitly by the given versionString, + * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}. + *

+ * @param versionString should be given as [MAJOR[.MINOR[.SUB]]] + * @param versionPattern the {@link java.util.regex.Pattern pattern} parser, must be compatible w/ {@link #getVersionNumberPattern(String)} + * + * @see #hasMajor() + * @see #hasMinor() + * @see #hasSub() + */ + public VersionNumber(final String versionString, final java.util.regex.Pattern versionPattern) { + // group1: \d* == digits major + // group2: \d* == digits minor + // group3: \d* == digits sub final int[] val = new int[3]; - for(int n=0; tok.hasMoreTokens() && n<3; n++) { - try { - final Matcher matcher = nonDigitsCutOff.matcher( tok.nextToken() ); - if(matcher.matches()) { - val[n] = Integer.parseInt(matcher.group(2)); + int _strEnd = 0; + short _state = 0; + try { + final Matcher matcher = versionPattern.matcher( versionString ); + if( matcher.lookingAt() ) { + _strEnd = matcher.end(); + final int groupCount = matcher.groupCount(); + if( 1 <= groupCount ) { + val[0] = Integer.parseInt(matcher.group(1)); + _state = HAS_MAJOR; + if( 2 <= groupCount ) { + val[1] = Integer.parseInt(matcher.group(2)); + _state |= HAS_MINOR; + if( 3 <= groupCount ) { + val[2] = Integer.parseInt(matcher.group(3)); + _state |= HAS_SUB; + } + } } - } catch (Exception e) { } - } + } + } catch (Exception e) { } + major = val[0]; minor = val[1]; sub = val[2]; + strEnd = _strEnd; + state = _state; } - + /** Returns true, if all version components are zero, otherwise false. */ public final boolean isZero() { return major == 0 && minor == 0 && sub == 0; } + /** Returns true, if the major component is defined explicitly, otherwise false. Undefined components has the value 0. */ + public final boolean hasMajor() { return 0 != ( HAS_MAJOR & state ); } + /** Returns true, if the optional minor component is defined explicitly, otherwise false. Undefined components has the value 0. */ + public final boolean hasMinor() { return 0 != ( HAS_MINOR & state ); } + /** Returns true, if the optional sub component is defined explicitly, otherwise false. Undefined components has the value 0. */ + public final boolean hasSub() { return 0 != ( HAS_SUB & state ); } + + /** + * If constructed with version-string, returns the string offset after the last matching character, + * or 0 if none matched, or -1 if not constructed with a string. + */ + public final int endOfStringMatch() { return strEnd; } + @Override public final int hashCode() { // 31 * x == (x << 5) - x -- cgit v1.2.3