Parse DSE versions number too

Sylvain Lebresne · Sylvain Lebresne · commit 12eb9b577100 · 2014-03-05T13:51:18.000+01:00
diff --git a/driver-core/src/main/java/com/datastax/driver/core/VersionNumber.java b/driver-core/src/main/java/com/datastax/driver/core/VersionNumber.java
@@ -34,20 +34,22 @@
  */
 public class VersionNumber implements Comparable<VersionNumber> {
 
-    private static final String VERSION_REGEXP = "(\\d+)\\.(\\d+)(\\.\\d+)?([~\\-]\\w[.\\w]*(?:\\-\\w[.\\w]*)*)?(\\+[.\\w]+)?";
+    private static final String VERSION_REGEXP = "(\\d+)\\.(\\d+)(\\.\\d+)?(\\.\\d+)?([~\\-]\\w[.\\w]*(?:\\-\\w[.\\w]*)*)?(\\+[.\\w]+)?";
     private static final Pattern pattern = Pattern.compile(VERSION_REGEXP);
 
     private final int major;
     private final int minor;
     private final int patch;
+    private final int dsePatch;
 
     private final String[] preReleases;
     private final String build;
 
-    private VersionNumber(int major, int minor, int patch, String[] preReleases, String build) {
+    private VersionNumber(int major, int minor, int patch, int dsePatch, String[] preReleases, String build) {
         this.major = major;
         this.minor = minor;
         this.patch = patch;
+        this.dsePatch = dsePatch;
         this.preReleases = preReleases;
         this.build = build;
     }
@@ -79,13 +81,16 @@ public static VersionNumber parse(String version) {
             String pa = matcher.group(3);
             int patch = pa == null || pa.isEmpty() ? 0 : Integer.parseInt(pa.substring(1)); // dropping the initial '.' since it's included this time
 
-            String pr = matcher.group(4);
+            String dse = matcher.group(4);
+            int dsePatch = dse == null || dse.isEmpty() ? -1 : Integer.parseInt(dse.substring(1)); // dropping the initial '.' since it's included this time
+
+            String pr = matcher.group(5);
             String[] preReleases = pr == null || pr.isEmpty() ? null : pr.substring(1).split("\\-"); // drop initial '-' or '~' then split on the remaining ones
 
-            String bl = matcher.group(5);
+            String bl = matcher.group(6);
             String build = bl == null || bl.isEmpty() ? null : bl.substring(1); // drop the initial '+'
 
-            return new VersionNumber(major, minor, patch, preReleases, build);
+            return new VersionNumber(major, minor, patch, dsePatch, preReleases, build);
         } catch (NumberFormatException e) {
             throw new IllegalArgumentException("Invalid version number: " + version);
         }
@@ -118,6 +123,20 @@ public int getPatch() {
         return patch;
     }
 
+    /**
+     * The DSE patch version number (will only be present for version of Cassandra in DSE).
+     * <p>
+     * DataStax Entreprise (DSE) adds a fourth number to the version number to track potential
+     * hot fixes and/or DSE specific patches that may have been applied to the Cassandra version.
+     * In that case, this method return that fourth number.
+     *
+     * @return the DSE patch version number, i.e. D in X.Y.Z.D, or -1 if the version number is
+     * not from DSE.
+     */
+    public int getDSEPatch() {
+        return dsePatch;
+    }
+
     /**
      * The pre-release labels if relevants, i.e. label1 and label2 in X.Y.Z-label1-lable2.
      *
@@ -154,6 +173,20 @@ public int compareTo(VersionNumber other) {
         if (patch > other.patch)
             return 1;
 
+        if (dsePatch < 0) {
+            if (other.dsePatch >= 0)
+                return -1;
+        } else {
+            if (other.dsePatch < 0)
+                return 1;
+
+            // Both are >= 0
+            if (dsePatch < other.dsePatch)
+                return -1;
+            if (dsePatch > other.dsePatch)
+                return 1;
+        }
+
         if (preReleases == null)
             return other.preReleases == null ? 0 : 1;
         if (other.preReleases == null)
@@ -179,19 +212,22 @@ public boolean equals(Object o) {
         return major == that.major
             && minor == that.minor
             && patch == that.patch
+            && dsePatch == that.dsePatch
             && (preReleases == null ? that.preReleases == null : Arrays.equals(preReleases, that.preReleases))
             && Objects.equal(build, that.build);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hashCode(major, minor, patch, preReleases, build);
+        return Objects.hashCode(major, minor, patch, dsePatch, preReleases, build);
     }
 
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append(major).append('.').append(minor).append('.').append(patch);
+        if (dsePatch >= 0)
+            sb.append('.').append(dsePatch);
         if (preReleases != null) {
             for (String preRelease : preReleases)
                 sb.append('-').append(preRelease);
diff --git a/driver-core/src/test/java/com/datastax/driver/core/VersionNumberTest.java b/driver-core/src/test/java/com/datastax/driver/core/VersionNumberTest.java
@@ -28,7 +28,8 @@ public void versionNumberTest() {
             "2.0.0",
             "2.0.0-beta1",
             "2.0.0-beta1-SNAPSHOT",
-            "2.0.0-beta1-SNAPSHOT+abc01"
+            "2.0.0-beta1-SNAPSHOT+abc01",
+            "2.0.0.22" // DSE
         };
 
         VersionNumber[] numbers = new VersionNumber[versions.length];
@@ -42,6 +43,7 @@ public void versionNumberTest() {
         assertEquals(numbers[1].compareTo(numbers[2]), 1);
         assertEquals(numbers[2].compareTo(numbers[3]), -1);
         assertEquals(numbers[3].compareTo(numbers[4]), 0);
+        assertEquals(numbers[1].compareTo(numbers[5]), -1);
 
         VersionNumber deb = VersionNumber.parse("2.0.0~beta1");
         assertEquals(deb, numbers[2]);
