JSpecify updates for Between

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java

@@ -622,7 +622,7 @@ static <T> IsEqualTo<T> isEqualTo(@Nullable T value) {
         return IsEqualTo.of(value);
     }
 
-    static <T> IsEqualTo<T> isEqualTo(Supplier<T> valueSupplier) {
+    static <T> IsEqualTo<T> isEqualTo(Supplier<@Nullable T> valueSupplier) {
         return isEqualTo(valueSupplier.get());
     }
 
@@ -638,15 +638,15 @@ static <T> IsEqualTo<T> isEqualToWhenPresent(@Nullable T value) {
         return IsEqualTo.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsEqualTo<T> isEqualToWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsEqualTo<T> isEqualToWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isEqualToWhenPresent(valueSupplier.get());
     }
 
     static <T> IsNotEqualTo<T> isNotEqualTo(@Nullable T value) {
         return IsNotEqualTo.of(value);
     }
 
-    static <T> IsNotEqualTo<T> isNotEqualTo(Supplier<T> valueSupplier) {
+    static <T> IsNotEqualTo<T> isNotEqualTo(Supplier<@Nullable T> valueSupplier) {
         return isNotEqualTo(valueSupplier.get());
     }
 
@@ -662,15 +662,15 @@ static <T> IsNotEqualTo<T> isNotEqualToWhenPresent(@Nullable T value) {
         return IsNotEqualTo.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsNotEqualTo<T> isNotEqualToWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsNotEqualTo<T> isNotEqualToWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isNotEqualToWhenPresent(valueSupplier.get());
     }
 
     static <T> IsGreaterThan<T> isGreaterThan(@Nullable T value) {
         return IsGreaterThan.of(value);
     }
 
-    static <T> IsGreaterThan<T> isGreaterThan(Supplier<T> valueSupplier) {
+    static <T> IsGreaterThan<T> isGreaterThan(Supplier<@Nullable T> valueSupplier) {
         return isGreaterThan(valueSupplier.get());
     }
 
@@ -686,15 +686,15 @@ static <T> IsGreaterThan<T> isGreaterThanWhenPresent(@Nullable T value) {
         return IsGreaterThan.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsGreaterThan<T> isGreaterThanWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsGreaterThan<T> isGreaterThanWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isGreaterThanWhenPresent(valueSupplier.get());
     }
 
     static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(@Nullable T value) {
         return IsGreaterThanOrEqualTo.of(value);
     }
 
-    static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(Supplier<T> valueSupplier) {
+    static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(Supplier<@Nullable T> valueSupplier) {
         return isGreaterThanOrEqualTo(valueSupplier.get());
     }
 
@@ -711,15 +711,15 @@ static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualToWhenPresent(@Nullable
         return IsGreaterThanOrEqualTo.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualToWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualToWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isGreaterThanOrEqualToWhenPresent(valueSupplier.get());
     }
 
     static <T> IsLessThan<T> isLessThan(@Nullable T value) {
         return IsLessThan.of(value);
     }
 
-    static <T> IsLessThan<T> isLessThan(Supplier<T> valueSupplier) {
+    static <T> IsLessThan<T> isLessThan(Supplier<@Nullable T> valueSupplier) {
         return isLessThan(valueSupplier.get());
     }
 
@@ -735,15 +735,15 @@ static <T> IsLessThan<T> isLessThanWhenPresent(@Nullable T value) {
         return IsLessThan.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsLessThan<T> isLessThanWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsLessThan<T> isLessThanWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isLessThanWhenPresent(valueSupplier.get());
     }
 
     static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(@Nullable T value) {
         return IsLessThanOrEqualTo.of(value);
     }
 
-    static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(Supplier<T> valueSupplier) {
+    static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(Supplier<@Nullable T> valueSupplier) {
         return isLessThanOrEqualTo(valueSupplier.get());
     }
 
@@ -759,7 +759,7 @@ static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualToWhenPresent(@Nullable T val
         return IsLessThanOrEqualTo.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualToWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualToWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isLessThanOrEqualToWhenPresent(valueSupplier.get());
     }
 
@@ -807,68 +807,68 @@ static <T> IsNotInWhenPresent<T> isNotInWhenPresent(@Nullable Collection<@Nullab
         return values == null ? IsNotInWhenPresent.empty() : IsNotInWhenPresent.of(values);
     }
 
-    static <T> IsBetween.Builder<T> isBetween(T value1) {
+    static <T> IsBetween.Builder<T> isBetween(@Nullable T value1) {
         return IsBetween.isBetween(value1);
     }
 
-    static <T> IsBetween.Builder<T> isBetween(Supplier<T> valueSupplier1) {
+    static <T> IsBetween.Builder<T> isBetween(Supplier<@Nullable T> valueSupplier1) {
         return isBetween(valueSupplier1.get());
     }
 
     static <T> IsBetween.WhenPresentBuilder<T> isBetweenWhenPresent(@Nullable T value1) {
         return IsBetween.isBetweenWhenPresent(value1);
     }
 
-    static <T> IsBetween.WhenPresentBuilder<T> isBetweenWhenPresent(Supplier<T> valueSupplier1) {
+    static <T> IsBetween.WhenPresentBuilder<T> isBetweenWhenPresent(Supplier<@Nullable T> valueSupplier1) {
         return isBetweenWhenPresent(valueSupplier1.get());
     }
 
-    static <T> IsNotBetween.Builder<T> isNotBetween(T value1) {
+    static <T> IsNotBetween.Builder<T> isNotBetween(@Nullable T value1) {
         return IsNotBetween.isNotBetween(value1);
     }
 
-    static <T> IsNotBetween.Builder<T> isNotBetween(Supplier<T> valueSupplier1) {
+    static <T> IsNotBetween.Builder<T> isNotBetween(Supplier<@Nullable T> valueSupplier1) {
         return isNotBetween(valueSupplier1.get());
     }
 
     static <T> IsNotBetween.WhenPresentBuilder<T> isNotBetweenWhenPresent(@Nullable T value1) {
         return IsNotBetween.isNotBetweenWhenPresent(value1);
     }
 
-    static <T> IsNotBetween.WhenPresentBuilder<T> isNotBetweenWhenPresent(Supplier<T> valueSupplier1) {
+    static <T> IsNotBetween.WhenPresentBuilder<T> isNotBetweenWhenPresent(Supplier<@Nullable T> valueSupplier1) {
         return isNotBetweenWhenPresent(valueSupplier1.get());
     }
 
     // for string columns, but generic for columns with type handlers
-    static <T> IsLike<T> isLike(T value) {
+    static <T> IsLike<T> isLike(@Nullable T value) {
         return IsLike.of(value);
     }
 
-    static <T> IsLike<T> isLike(Supplier<T> valueSupplier) {
+    static <T> IsLike<T> isLike(Supplier<@Nullable T> valueSupplier) {
         return isLike(valueSupplier.get());
     }
 
     static <T> IsLike<T> isLikeWhenPresent(@Nullable T value) {
         return IsLike.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsLike<T> isLikeWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsLike<T> isLikeWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isLikeWhenPresent(valueSupplier.get());
     }
 
-    static <T> IsNotLike<T> isNotLike(T value) {
+    static <T> IsNotLike<T> isNotLike(@Nullable T value) {
         return IsNotLike.of(value);
     }
 
-    static <T> IsNotLike<T> isNotLike(Supplier<T> valueSupplier) {
+    static <T> IsNotLike<T> isNotLike(Supplier<@Nullable T> valueSupplier) {
         return isNotLike(valueSupplier.get());
     }
 
     static <T> IsNotLike<T> isNotLikeWhenPresent(@Nullable T value) {
         return IsNotLike.of(value).filter(Objects::nonNull);
     }
 
-    static <T> IsNotLike<T> isNotLikeWhenPresent(Supplier<T> valueSupplier) {
+    static <T> IsNotLike<T> isNotLikeWhenPresent(Supplier<@Nullable T> valueSupplier) {
         return isNotLikeWhenPresent(valueSupplier.get());
     }
 
@@ -882,35 +882,35 @@ static IsEqualTo<Boolean> isFalse() {
     }
 
     // conditions for strings only
-    static IsLikeCaseInsensitive isLikeCaseInsensitive(String value) {
+    static IsLikeCaseInsensitive isLikeCaseInsensitive(@Nullable String value) {
         return IsLikeCaseInsensitive.of(value);
     }
 
-    static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<String> valueSupplier) {
+    static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<@Nullable String> valueSupplier) {
         return isLikeCaseInsensitive(valueSupplier.get());
     }
 
     static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(@Nullable String value) {
         return IsLikeCaseInsensitive.of(value).filter(Objects::nonNull);
     }
 
-    static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier) {
+    static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
         return isLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 
-    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value) {
+    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(@Nullable String value) {
         return IsNotLikeCaseInsensitive.of(value);
     }
 
-    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {
+    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<@Nullable String> valueSupplier) {
         return isNotLikeCaseInsensitive(valueSupplier.get());
     }
 
     static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(@Nullable String value) {
         return IsNotLikeCaseInsensitive.of(value).filter(Objects::nonNull);
     }
 
-    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier) {
+    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
         return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 

src/main/java/org/mybatis/dynamic/sql/where/condition/IsBetween.java

@@ -88,7 +88,7 @@ public <R> IsBetween<R> map(Function<? super T, ? extends R> mapper) {
         return map(mapper, mapper);
     }
 
-    public static <T> Builder<T> isBetween(T value1) {
+    public static <T> Builder<T> isBetween(@Nullable T value1) {
         return new Builder<>(value1);
     }
 
@@ -97,7 +97,7 @@ public static <T> WhenPresentBuilder<T> isBetweenWhenPresent(@Nullable T value1)
     }
 
     public static class Builder<T> extends AndGatherer<T, IsBetween<T>> {
-        private Builder(T value1) {
+        private Builder(@Nullable T value1) {
             super(value1);
         }
 

src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotBetween.java

@@ -89,7 +89,7 @@ public <R> IsNotBetween<R> map(Function<? super T, ? extends R> mapper) {
         return map(mapper, mapper);
     }
 
-    public static <T> Builder<T> isNotBetween(T value1) {
+    public static <T> Builder<T> isNotBetween(@Nullable T value1) {
         return new Builder<>(value1);
     }
 
@@ -99,7 +99,7 @@ public static <T> WhenPresentBuilder<T> isNotBetweenWhenPresent(@Nullable T valu
 
     public static class Builder<T> extends AndGatherer<T, IsNotBetween<T>> {
 
-        private Builder(T value1) {
+        private Builder(@Nullable T value1) {
             super(value1);
         }