diff options
Diffstat (limited to 'src')
4 files changed, 399 insertions, 39 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; } diff --git a/src/java/jogamp/common/os/PlatformPropsImpl.java b/src/java/jogamp/common/os/PlatformPropsImpl.java index 5b8bf0e..6089cc2 100644 --- a/src/java/jogamp/common/os/PlatformPropsImpl.java +++ b/src/java/jogamp/common/os/PlatformPropsImpl.java @@ -77,13 +77,13 @@ public abstract class PlatformPropsImpl { OS = System.getProperty("os.name"); OS_lower = OS.toLowerCase(); OS_VERSION = System.getProperty("os.version"); - OS_VERSION_NUMBER = new VersionNumber(OS_VERSION, "."); + OS_VERSION_NUMBER = new VersionNumber(OS_VERSION); ARCH = System.getProperty("os.arch"); ARCH_lower = ARCH.toLowerCase(); JAVA_VENDOR = System.getProperty("java.vendor"); JAVA_VENDOR_URL = System.getProperty("java.vendor.url"); JAVA_VERSION = System.getProperty("java.version"); - JAVA_VERSION_NUMBER = new VersionNumber(JAVA_VERSION, "."); + JAVA_VERSION_NUMBER = new VersionNumber(JAVA_VERSION); JAVA_VM_NAME = System.getProperty("java.vm.name"); JAVA_RUNTIME_NAME = getJavaRuntimeNameImpl(); JAVA_SE = initIsJavaSE(); diff --git a/src/junit/com/jogamp/common/util/TestVersionNumber.java b/src/junit/com/jogamp/common/util/TestVersionNumber.java index f1ed157..e46213a 100644 --- a/src/junit/com/jogamp/common/util/TestVersionNumber.java +++ b/src/junit/com/jogamp/common/util/TestVersionNumber.java @@ -39,58 +39,255 @@ public class TestVersionNumber extends JunitTracer { @Test public void test01() { - final String delim = "."; - final String vs00 = "1.0.16"; final String vs01 = "OpenGL ES GLSL ES 1.0.16"; final String vs02 = "1.0.16 OpenGL ES GLSL ES"; final VersionNumber vn0 = new VersionNumber(1, 0, 16); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); + + VersionNumber vn; + + vn = new VersionNumber(vs00); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs01); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs02); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + } + @Test + public void test01b() { + final String delim = ","; + + final String vs00 = "1,0,16"; + final String vs01 = "OpenGL ES GLSL ES 1,0,16"; + final String vs02 = "1,0,16 OpenGL ES GLSL ES"; + final VersionNumber vn0 = new VersionNumber(1, 0, 16); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); VersionNumber vn; vn = new VersionNumber(vs00, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); Assert.assertEquals(vn0, vn); + vn = new VersionNumber(vs01, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); Assert.assertEquals(vn0, vn); + vn = new VersionNumber(vs02, delim); - Assert.assertEquals(vn0, vn); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); } @Test public void test02() { - final String delim = "."; - final String vs00 = "4.20"; final String vs01 = "COMPANY via Stupid tool 4.20"; final String vs02 = "4.20 COMPANY via Stupid tool"; final VersionNumber vn0 = new VersionNumber(4, 20, 0); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); + + VersionNumber vn; + + vn = new VersionNumber(vs00); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(!vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs01); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(!vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs02); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(!vn.hasSub()); + Assert.assertEquals(vn0, vn); + } + + @Test + public void test02b() { + final String delim = ","; + + final String vs00 = "4,20"; + final String vs01 = "COMPANY via Stupid tool 4,20"; + final String vs02 = "4,20 COMPANY via Stupid tool"; + final VersionNumber vn0 = new VersionNumber(4, 20, 0); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); VersionNumber vn; vn = new VersionNumber(vs00, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(!vn.hasSub()); Assert.assertEquals(vn0, vn); + vn = new VersionNumber(vs01, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(!vn.hasSub()); Assert.assertEquals(vn0, vn); + vn = new VersionNumber(vs02, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(!vn.hasSub()); Assert.assertEquals(vn0, vn); } @Test public void test03() { - final String delim = "."; - final String vs00 = "A10.11.12b"; - final String vs01 = "Prelim Text 10.Funny11 .Weird12 Something is odd"; - final String vs02 = "Prelim Text 10 .Funny11l1.Weird12 2 Something is odd"; + final String vs01 = "Prelim Text 10.Funny11.Weird12 Something is odd"; + final String vs02 = "Prelim Text 10.Funny11l1.Weird12 2 Something is odd"; final VersionNumber vn0 = new VersionNumber(10, 11, 12); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); + + VersionNumber vn; + + vn = new VersionNumber(vs00); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs01); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs02); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + } + + @Test + public void test03b() { + final String delim = ","; + + final String vs00 = "A10,11,12b"; + final String vs01 = "Prelim Text 10,Funny11,Weird12 Something is odd"; + final String vs02 = "Prelim Text 10,Funny11l1,Weird12 2 Something is odd"; + final VersionNumber vn0 = new VersionNumber(10, 11, 12); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); VersionNumber vn; vn = new VersionNumber(vs00, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); Assert.assertEquals(vn0, vn); + vn = new VersionNumber(vs01, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs02, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + } + + @Test + public void test04() { + final String vs00 = "A10.11.12b (git-d6c318e)"; + final String vs01 = "Prelim Text 10.Funny11.Weird12 Something is odd (git-d6c318e)"; + final String vs02 = "Prelim Text 10.Funny11l1.Weird12 2 Something is odd (git-d6c318e)"; + final VersionNumber vn0 = new VersionNumber(10, 11, 12); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); + + VersionNumber vn; + + vn = new VersionNumber(vs00); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs01); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs02); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + } + @Test + public void test04b() { + final String delim = ","; + + final String vs00 = "A10,11,12b (git-d6c318e)"; + final String vs01 = "Prelim Text 10,Funny11,Weird12 Something is odd (git-d6c318e)"; + final String vs02 = "Prelim Text 10,Funny11l1,Weird12 2 Something is odd (git-d6c318e)"; + final VersionNumber vn0 = new VersionNumber(10, 11, 12); + Assert.assertTrue(vn0.hasMajor()); + Assert.assertTrue(vn0.hasMinor()); + Assert.assertTrue(vn0.hasSub()); + + VersionNumber vn; + + vn = new VersionNumber(vs00, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + + vn = new VersionNumber(vs01, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); + Assert.assertEquals(vn0, vn); + vn = new VersionNumber(vs02, delim); + Assert.assertTrue(vn.hasMajor()); + Assert.assertTrue(vn.hasMinor()); + Assert.assertTrue(vn.hasSub()); Assert.assertEquals(vn0, vn); } |