Enhance VersionNumber*: Use only RegExp and cache default (no wrapped whitespace tokenizer); String match: Store end-of-match and flag defined components.

2 files changed, 191 insertions, 28 deletions

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}. 
+ * <p>
+ * For the latter case, you can query whether a component has been defined explicitly by the given <code>versionString</code>,
+ * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}.
+ * </p>
+ * <p>
+ * The state whether a component is defined explicitly <i>is not considered</i>
+ * in the {@link #hashCode()}, {@link #equals(Object)} or {@link #compareTo(Object)} methods,
+ * since the version number itself is treated regardless.
+ * </p>
  */
 public class VersionNumber implements Comparable<Object> {
 
-    /** 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: 
+     * <pre>
+     *   "\\D*(\\d+)[^\\"+delim+"\\s]*(?:\\"+delim+"\\D*(\\d+)[^\\"+delim+"\\s]*(?:\\"+delim+"\\D*(\\d+))?)?"
+     * </pre>
+     * </p>
+     * <p>
+     * A whitespace within the version number will end the parser. 
+     * </p>
+     * <p>
+     * Capture groups represent the major (1), optional minor (2) and optional sub version number (3) component in this order.
+     * </p>
+     * <p>
+     * Each capture group ignores any leading non-digit and uses only contiguous digits, i.e. ignores pending non-digits. 
+     * </p>
+     * @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 "<b>.</b>".
+     * <p>
+     * Instance is cached.
+     * </p> 
+     */ 
+    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.
      * <p>
-     * Parser first tokenizes the input versionString w/ given delimiter.
-     * </p>
+     * Utilizing the default {@link java.util.regex.Pattern pattern} parser with delimiter "<b>.</b>", see {@link #getDefaultVersionNumberPattern()}.
+     * </p> 
      * <p>
-     * 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 <code>versionString</code>,
+     * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}.
      * </p>
+     * @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.
+     * <p>
+     * Utilizing {@link java.util.regex.Pattern pattern} parser created via {@link #getVersionNumberPattern(String)}.
+     * </p> 
      * <p>
-     * 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 <code>versionString</code>,
+     * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}.
      * </p>
      * @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.
+     * <p>
+     * You can query whether a component has been defined explicitly by the given <code>versionString</code>,
+     * via {@link #hasMajor()}, {@link #hasMinor()} and {@link #hasSub()}.
+     * </p>
+     * @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 <code>true</code>, if all version components are zero, otherwise <code>false</code>. */ 
     public final boolean isZero() {
         return major == 0 && minor == 0 && sub == 0;
     }
     
+    /** Returns <code>true</code>, if the major component is defined explicitly, otherwise <code>false</code>. Undefined components has the value <code>0</code>. */
+    public final boolean hasMajor() { return 0 != ( HAS_MAJOR & state ); } 
+    /** Returns <code>true</code>, if the optional minor component is defined explicitly, otherwise <code>false</code>. Undefined components has the value <code>0</code>. */
+    public final boolean hasMinor() { return 0 != ( HAS_MINOR & state ); }
+    /** Returns <code>true</code>, if the optional sub component is defined explicitly, otherwise <code>false</code>. Undefined components has the value <code>0</code>. */
+    public final boolean hasSub()   { return 0 != ( HAS_SUB & state ); }
+    
+    /** 
+     * If constructed with <code>version-string</code>, returns the string offset <i>after</i> the last matching character,
+     * or <code>0</code> if none matched, or <code>-1</code> if not constructed with a string.
+     */
+    public final int endOfStringMatch() { return strEnd; }
+    
     @Override
     public final int hashCode() {
         // 31 * x == (x << 5) - x
diff --git a/src/java/com/jogamp/common/util/VersionNumberString.java b/src/java/com/jogamp/common/util/VersionNumberString.java
index 7e68aea..143d57c 100644
--- a/src/java/com/jogamp/common/util/VersionNumberString.java
+++ b/src/java/com/jogamp/common/util/VersionNumberString.java
@@ -34,24 +34,52 @@ package com.jogamp.common.util;
  */
 public class VersionNumberString extends VersionNumber {
 
-    /** A {@link #isZero() zero} version instance. */
-    public static final VersionNumberString zeroVersion = new VersionNumberString(0, 0, 0, "n/a");
+    /** 
+     * A {@link #isZero() zero} version instance, w/o any component defined explicitly. 
+     * @see #hasMajor()
+     * @see #hasMinor()
+     * @see #hasSub() 
+     */
+    public static final VersionNumberString zeroVersion = new VersionNumberString(0, 0, 0, -1, (short)0, "n/a");
     
     protected final String strVal;
 
+    protected VersionNumberString(int majorRev, int minorRev, int subMinorRev, int strEnd, short _state, String versionString) {
+        super(majorRev, minorRev, subMinorRev, strEnd, _state);
+        strVal = versionString;
+    }
+    
+    /**
+     * See {@link VersionNumber#VersionNumber(int, int, int)}.
+     */
     public VersionNumberString(int majorRev, int minorRev, int subMinorRev, String versionString) {
-        super(majorRev, minorRev, subMinorRev);
+        this(majorRev, minorRev, subMinorRev, -1, (short)(HAS_MAJOR | HAS_MINOR | HAS_SUB), versionString);
+    }
+    
+    /**
+     * See {@link VersionNumber#VersionNumber(String)}.
+     */
+    public VersionNumberString(final String versionString) {
+        super( versionString);
         strVal = versionString;
     }
     
     /**
      * See {@link VersionNumber#VersionNumber(String, String)}.
      */
-    public VersionNumberString(String versionString, String delim) {
+    public VersionNumberString(final String versionString, final String delim) {
         super( versionString, delim);
         strVal = versionString;
     }
     
+    /**
+     * See {@link VersionNumber#VersionNumber(String, java.util.regex.Pattern)}.
+     */
+    public VersionNumberString(final String versionString, final java.util.regex.Pattern versionPattern) {
+        super( versionString, versionPattern);
+        strVal = versionString;
+    }
+    
     /** Returns the version string this version number is derived from. */
     public final String getVersionString() { return strVal; }