gluegen: remove trailing whitespace

Signed-off-by: Harvey Harrison <[email protected]>

1 files changed, 38 insertions, 38 deletions

diff --git a/src/java/com/jogamp/common/util/VersionNumber.java b/src/java/com/jogamp/common/util/VersionNumber.java
index b1d8963..addc879 100644
--- a/src/java/com/jogamp/common/util/VersionNumber.java
+++ b/src/java/com/jogamp/common/util/VersionNumber.java
@@ -33,7 +33,7 @@ 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}. 
+ * 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()}.
@@ -46,45 +46,45 @@ import java.util.regex.Matcher;
  */
 public class VersionNumber implements Comparable<Object> {
 
-    /** 
-     * A {@link #isZero() zero} version instance, w/o any component defined explicitly. 
+    /**
+     * A {@link #isZero() zero} version instance, w/o any component defined explicitly.
      * @see #hasMajor()
      * @see #hasMinor()
-     * @see #hasSub() 
+     * @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: 
+     * 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. 
+     * 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. 
+     * 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)} 
+     * Returns the default {@link java.util.regex.Pattern pattern} using {@link #getVersionNumberPattern(String)}
      * with delimiter "<b>.</b>".
      * <p>
      * Instance is cached.
-     * </p> 
-     */ 
+     * </p>
+     */
     public static java.util.regex.Pattern getDefaultVersionNumberPattern() {
-        if( null == defPattern ) { // volatile dbl-checked-locking OK 
+        if( null == defPattern ) { // volatile dbl-checked-locking OK
             synchronized( VersionNumber.class ) {
                 if( null == defPattern ) {
                     defPattern = getVersionNumberPattern(".");
@@ -96,7 +96,7 @@ public class VersionNumber implements Comparable<Object> {
     private static volatile java.util.regex.Pattern defPattern = null;
 
     protected final int major, minor, sub, strEnd;
-    
+
     protected final short state;
     protected final static short HAS_MAJOR = 1 << 0 ;
     protected final static short HAS_MINOR = 1 << 1 ;
@@ -109,12 +109,12 @@ public class VersionNumber implements Comparable<Object> {
         strEnd = _strEnd;
         state = _state;
     }
-    
-    /** 
+
+    /**
      * Explicit version number instantiation, with all components defined explicitly.
      * @see #hasMajor()
      * @see #hasMinor()
-     * @see #hasSub() 
+     * @see #hasSub()
      */
     public VersionNumber(int majorRev, int minorRev, int subMinorRev) {
         this(majorRev, minorRev, subMinorRev, -1, (short)(HAS_MAJOR | HAS_MINOR | HAS_SUB));
@@ -124,41 +124,41 @@ public class VersionNumber implements Comparable<Object> {
      * String derived version number instantiation.
      * <p>
      * Utilizing the default {@link java.util.regex.Pattern pattern} parser with delimiter "<b>.</b>", see {@link #getDefaultVersionNumberPattern()}.
-     * </p> 
+     * </p>
      * <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]]]
-     * 
+     *
      * @see #hasMajor()
      * @see #hasMinor()
-     * @see #hasSub() 
+     * @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>
      * <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 delim the delimiter, e.g. "."
-     * 
+     *
      * @see #hasMajor()
      * @see #hasMinor()
-     * @see #hasSub() 
+     * @see #hasSub()
      */
     public VersionNumber(final String versionString, final String delim) {
         this(versionString, getVersionNumberPattern(delim));
     }
-    
+
     /**
      * String derived version number instantiation.
      * <p>
@@ -167,10 +167,10 @@ public class VersionNumber implements Comparable<Object> {
      * </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() 
+     * @see #hasSub()
      */
     public VersionNumber(final String versionString, final java.util.regex.Pattern versionPattern) {
         // group1: \d* == digits major
@@ -198,32 +198,32 @@ public class VersionNumber implements Comparable<Object> {
                 }
             }
         } 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>. */ 
+
+    /** 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 ); } 
+    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
@@ -239,7 +239,7 @@ public class VersionNumber implements Comparable<Object> {
         }
         return false;
     }
-    
+
     @Override
     public final int compareTo(Object o) {
         if ( ! ( o instanceof VersionNumber ) ) {
@@ -265,7 +265,7 @@ public class VersionNumber implements Comparable<Object> {
         }
         return 0;
     }
-    
+
     public final int getMajor() {
         return major;
     }