#158: VersionRange with open boundaries (#159)

Author: MattesMrzik

cli/src/main/java/com/devonfw/tools/ide/version/BoundaryType.java

@@ -0,0 +1,19 @@
+package com.devonfw.tools.ide.version;
+
+/**
+ * Enum representing the type of interval regarding its boundaries.
+ */
+public enum BoundaryType {
+
+  /** Closed interval - includes the specified values at the boundaries. */
+  CLOSED,
+
+  /** Open interval - excludes the specified values at the boundaries. */
+  OPEN,
+
+  /** Left open interval - excludes the lower bound but includes the upper bound. */
+  LEFT_OPEN,
+
+  /** Right open interval - includes the lower bound but excludes the upper bound. */
+  RIGHT_OPEN
+}

cli/src/main/java/com/devonfw/tools/ide/version/VersionObject.java

@@ -3,12 +3,11 @@
 /**
  * Abstract base interface for a version object such as {@link VersionIdentifier} and {@link VersionSegment}.
  *
- *
  * {@link Comparable} for versions with an extended contract. If two versions are not strictly comparable (e.g.
  * "1.apple" and "1.banana") we fall back to some heuristics (e.g. lexicographical comparison for
- * {@link VersionSegment#getLettersString() letters} that we do not understand (e.g. "apple" < "banana"). Therefore you can
- * use {@link #compareVersion(Object)} to get a {@link VersionComparisonResult} that contains the additional information
- * as {@link VersionComparisonResult#isUnsafe() unsafe} flag.
+ * {@link VersionSegment#getLettersString() letters} that we do not understand (e.g. "apple" < "banana"). Therefore, you
+ * can use {@link #compareVersion(Object)} to get a {@link VersionComparisonResult} that contains the additional
+ * information as {@link VersionComparisonResult#isUnsafe() unsafe} flag.
  *
  * @param <T> type of the object to compare (this class itself).
  */

cli/src/main/java/com/devonfw/tools/ide/version/VersionRange.java

@@ -1,14 +1,58 @@
 package com.devonfw.tools.ide.version;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
 /**
- * Container for a range of versions.
+ * Container for a range of versions. The lower and upper bounds can be exclusive or inclusive. If a bound is null, it
+ * means that this direction is unbounded. The boolean defining whether this bound is inclusive or exclusive is ignored
+ * in this case.
  */
 public final class VersionRange implements Comparable<VersionRange> {
 
   private final VersionIdentifier min;
 
   private final VersionIdentifier max;
 
+  private final boolean leftIsExclusive;
+
+  private final boolean rightIsExclusive;
+
+  private static final String VERSION_SEPARATOR = ">";
+
+  private static final String START_EXCLUDING_PREFIX = "(";
+
+  private static final String START_INCLUDING_PREFIX = "[";
+
+  private static final String END_EXCLUDING_SUFFIX = ")";
+
+  private static final String END_INCLUDING_SUFFIX = "]";
+
+  public static String getVersionSeparator() {
+
+    return VERSION_SEPARATOR;
+  }
+
+  public static String getStartExcludingPrefix() {
+
+    return START_EXCLUDING_PREFIX;
+  }
+
+  public static String getStartIncludingPrefix() {
+
+    return START_INCLUDING_PREFIX;
+  }
+
+  public static String getEndExcludingSuffix() {
+
+    return END_EXCLUDING_SUFFIX;
+  }
+
+  public static String getEndIncludingSuffix() {
+
+    return END_INCLUDING_SUFFIX;
+  }
+
   /**
    * The constructor.
    *
@@ -20,6 +64,42 @@ public VersionRange(VersionIdentifier min, VersionIdentifier max) {
     super();
     this.min = min;
     this.max = max;
+    this.leftIsExclusive = false;
+    this.rightIsExclusive = false;
+  }
+
+  /**
+   * The constructor.
+   *
+   * @param min the {@link #getMin() minimum}.
+   * @param max the {@link #getMax() maximum}.
+   * @param boundaryType the {@link BoundaryType} defining whether the boundaries of the range are inclusive or
+   *        exclusive.
+   */
+  public VersionRange(VersionIdentifier min, VersionIdentifier max, BoundaryType boundaryType) {
+
+    super();
+    this.min = min;
+    this.max = max;
+    this.leftIsExclusive = BoundaryType.LEFT_OPEN.equals(boundaryType) || BoundaryType.OPEN.equals(boundaryType);
+    this.rightIsExclusive = BoundaryType.RIGHT_OPEN.equals(boundaryType) || BoundaryType.OPEN.equals(boundaryType);
+  }
+
+  /**
+   * The constructor.
+   *
+   * @param min the {@link #getMin() minimum}.
+   * @param max the {@link #getMax() maximum}.
+   * @param leftIsExclusive - {@code true} if the {@link #getMin() minimum} is exclusive, {@code false} otherwise.
+   * @param rightIsExclusive - {@code true} if the {@link #getMax() maximum} is exclusive, {@code false} otherwise.
+   */
+  public VersionRange(VersionIdentifier min, VersionIdentifier max, boolean leftIsExclusive, boolean rightIsExclusive) {
+
+    super();
+    this.min = min;
+    this.max = max;
+    this.leftIsExclusive = leftIsExclusive;
+    this.rightIsExclusive = rightIsExclusive;
   }
 
   /**
@@ -38,6 +118,38 @@ public VersionIdentifier getMax() {
     return this.max;
   }
 
+  /**
+   * @return {@code true} if the {@link #getMin() minimum} is exclusive, {@code false} otherwise.
+   */
+  public boolean isLeftExclusive() {
+
+    return this.leftIsExclusive;
+  }
+
+  /**
+   * @return {@code true} if the {@link #getMax() maximum} is exclusive, {@code false} otherwise.
+   */
+  public boolean isRightExclusive() {
+
+    return this.rightIsExclusive;
+  }
+
+  /**
+   * @return the {@link BoundaryType} defining whether the boundaries of the range are inclusive or exclusive.
+   */
+  public BoundaryType getBoundaryType() {
+
+    if (this.leftIsExclusive && this.rightIsExclusive) {
+      return BoundaryType.OPEN;
+    } else if (this.leftIsExclusive) {
+      return BoundaryType.LEFT_OPEN;
+    } else if (this.rightIsExclusive) {
+      return BoundaryType.RIGHT_OPEN;
+    } else {
+      return BoundaryType.CLOSED;
+    }
+  }
+
   /**
    * @param version the {@link VersionIdentifier} to check.
    * @return {@code true} if the given {@link VersionIdentifier} is contained in this {@link VersionRange},
@@ -46,12 +158,18 @@ public VersionIdentifier getMax() {
   public boolean contains(VersionIdentifier version) {
 
     if (this.min != null) {
-      if (version.isLess(this.min)) {
+      VersionComparisonResult compareMin = version.compareVersion(this.min);
+      if (compareMin.isLess()) {
+        return false;
+      } else if (compareMin.isEqual() && this.leftIsExclusive) {
         return false;
       }
     }
     if (this.max != null) {
-      if (version.isGreater(this.max)) {
+      VersionComparisonResult compareMax = version.compareVersion(this.max);
+      if (compareMax.isGreater()) {
+        return false;
+      } else if (compareMax.isEqual() && this.rightIsExclusive) {
         return false;
       }
     }
@@ -69,33 +187,67 @@ public int compareTo(VersionRange o) {
       }
       return -1;
     }
-    return this.min.compareTo(o.min);
+    int compareMins = this.min.compareTo(o.min);
+    if (compareMins == 0) {
+      return this.leftIsExclusive == o.leftIsExclusive ? 0 : this.leftIsExclusive ? 1 : -1;
+    } else {
+      return compareMins;
+    }
   }
 
   @Override
+  public boolean equals(Object obj) {
+
+    if (this == obj) {
+      return true;
+    } else if ((obj == null) || (getClass() != obj.getClass())) {
+      return false;
+    }
+    VersionRange o = (VersionRange) obj;
+    if (this.min == null && this.max == null) {
+      return o.min == null && o.max == null;
+    } else if (this.min == null) {
+      return o.min == null && this.max.equals(o.max) && this.rightIsExclusive == o.rightIsExclusive;
+    } else if (this.max == null) {
+      return this.min.equals(o.min) && o.max == null && this.leftIsExclusive == o.leftIsExclusive;
+    }
+    return this.min.equals(o.min) && this.leftIsExclusive == o.leftIsExclusive && this.max.equals(o.max)
+        && this.rightIsExclusive == o.rightIsExclusive;
+  }
+
+  @Override
+  @JsonValue
   public String toString() {
 
     StringBuilder sb = new StringBuilder();
+    sb.append(this.leftIsExclusive ? START_EXCLUDING_PREFIX : START_INCLUDING_PREFIX);
     if (this.min != null) {
       sb.append(this.min);
     }
-    sb.append('>');
+    sb.append(VERSION_SEPARATOR);
     if (this.max != null) {
       sb.append(this.max);
     }
+    sb.append(this.rightIsExclusive ? END_EXCLUDING_SUFFIX : END_INCLUDING_SUFFIX);
     return sb.toString();
   }
 
   /**
    * @param value the {@link #toString() string representation} of a {@link VersionRange} to parse.
    * @return the parsed {@link VersionRange}.
    */
+  @JsonCreator
   public static VersionRange of(String value) {
 
-    int index = value.indexOf('>');
+    boolean leftIsExclusive = value.startsWith(START_EXCLUDING_PREFIX);
+    boolean rightIsExclusive = value.endsWith(END_EXCLUDING_SUFFIX);
+    value = removeAffixes(value);
+
+    int index = value.indexOf(VERSION_SEPARATOR);
     if (index == -1) {
       return null; // log warning?
     }
+
     VersionIdentifier min = null;
     if (index > 0) {
       min = VersionIdentifier.of(value.substring(0, index));
@@ -105,7 +257,22 @@ public static VersionRange of(String value) {
     if (!maxString.isEmpty()) {
       max = VersionIdentifier.of(maxString);
     }
-    return new VersionRange(min, max);
+    return new VersionRange(min, max, leftIsExclusive, rightIsExclusive);
+  }
+
+  private static String removeAffixes(String value) {
+
+    if (value.startsWith(START_EXCLUDING_PREFIX)) {
+      value = value.substring(START_EXCLUDING_PREFIX.length());
+    } else if (value.startsWith(START_INCLUDING_PREFIX)) {
+      value = value.substring(START_INCLUDING_PREFIX.length());
+    }
+    if (value.endsWith(END_EXCLUDING_SUFFIX)) {
+      value = value.substring(0, value.length() - END_EXCLUDING_SUFFIX.length());
+    } else if (value.endsWith(END_INCLUDING_SUFFIX)) {
+      value = value.substring(0, value.length() - END_EXCLUDING_SUFFIX.length());
+    }
+    return value;
   }
 
 }