Define a map template method for single value

jeffgbutler · jeffgbutler · commit 1da7647981bb · 2025-03-13T09:39:14.000-04:00
diff --git a/src/main/java/org/mybatis/dynamic/sql/AbstractSingleValueCondition.java b/src/main/java/org/mybatis/dynamic/sql/AbstractSingleValueCondition.java
@@ -64,6 +64,17 @@ protected <R, S extends AbstractSingleValueCondition<R>> S mapSupport(Function<?
      */
     public abstract AbstractSingleValueCondition<T> filter(Predicate<? super T> predicate);
 
+    /**
+     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
+     * condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to the value, if renderable
+     * @param <R> type of the new condition
+     * @return a new condition with the result of applying the mapper to the value of this condition,
+     *     if renderable, otherwise a condition that will not render.
+     */
+    public abstract <R> AbstractSingleValueCondition<R> map(Function<? super T, ? extends R> mapper);
+
     public abstract String operator();
 
     @Override
diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java
@@ -882,35 +882,36 @@ static IsEqualTo<Boolean> isFalse() {
     }
 
     // conditions for strings only
-    static IsLikeCaseInsensitive isLikeCaseInsensitive(String value) {
+    static IsLikeCaseInsensitive<String> isLikeCaseInsensitive(String value) {
         return IsLikeCaseInsensitive.of(value);
     }
 
-    static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<String> valueSupplier) {
+    static IsLikeCaseInsensitive<String> isLikeCaseInsensitive(Supplier<String> valueSupplier) {
         return isLikeCaseInsensitive(valueSupplier.get());
     }
 
-    static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(@Nullable String value) {
+    static IsLikeCaseInsensitive<String> isLikeCaseInsensitiveWhenPresent(@Nullable String value) {
         return value == null ? IsLikeCaseInsensitive.empty() : IsLikeCaseInsensitive.of(value);
     }
 
-    static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
+    static IsLikeCaseInsensitive<String> isLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
         return isLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 
-    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value) {
+    static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitive(String value) {
         return IsNotLikeCaseInsensitive.of(value);
     }
 
-    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {
+    static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {
         return isNotLikeCaseInsensitive(valueSupplier.get());
     }
 
-    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(@Nullable String value) {
+    static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitiveWhenPresent(@Nullable String value) {
         return value == null ? IsNotLikeCaseInsensitive.empty() : IsNotLikeCaseInsensitive.of(value);
     }
 
-    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
+    static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitiveWhenPresent(
+            Supplier<@Nullable String> valueSupplier) {
         return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/CaseInsensitiveRenderableCondition.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/CaseInsensitiveRenderableCondition.java
@@ -20,11 +20,11 @@
 import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.util.FragmentAndParameters;
 
-public interface CaseInsensitiveRenderableCondition extends RenderableCondition<String> {
+public interface CaseInsensitiveRenderableCondition<T> extends RenderableCondition<T> {
 
     @Override
     default FragmentAndParameters renderLeftColumn(RenderingContext renderingContext,
-                                                   BindableColumn<String> leftColumn) {
+                                                   BindableColumn<T> leftColumn) {
         return RenderableCondition.super.renderLeftColumn(renderingContext, leftColumn)
                 .mapFragment(s -> "upper(" + s + ")"); //$NON-NLS-1$ //$NON-NLS-2$
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsEqualTo.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsEqualTo.java
@@ -59,15 +59,7 @@ public IsEqualTo<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsEqualTo::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @param <R> type of the new condition
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsEqualTo<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsEqualTo::new, IsEqualTo::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsGreaterThan.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsGreaterThan.java
@@ -58,15 +58,7 @@ public IsGreaterThan<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsGreaterThan::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @param <R> type of the new condition
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsGreaterThan<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsGreaterThan::new, IsGreaterThan::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsGreaterThanOrEqualTo.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsGreaterThanOrEqualTo.java
@@ -58,15 +58,7 @@ public IsGreaterThanOrEqualTo<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsGreaterThanOrEqualTo::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @param <R> type of the new condition
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsGreaterThanOrEqualTo<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsGreaterThanOrEqualTo::new, IsGreaterThanOrEqualTo::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitive.java
@@ -27,7 +27,7 @@
 import org.mybatis.dynamic.sql.util.Validator;
 
 public class IsInCaseInsensitive extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition {
+        implements CaseInsensitiveRenderableCondition<String> {
     private static final IsInCaseInsensitive EMPTY = new IsInCaseInsensitive(Collections.emptyList());
 
     public static IsInCaseInsensitive empty() {
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitiveWhenPresent.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsInCaseInsensitiveWhenPresent.java
@@ -27,7 +27,7 @@
 import org.mybatis.dynamic.sql.util.Utilities;
 
 public class IsInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition {
+        implements CaseInsensitiveRenderableCondition<String> {
     private static final IsInCaseInsensitiveWhenPresent EMPTY =
             new IsInCaseInsensitiveWhenPresent(Collections.emptyList());
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLessThan.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLessThan.java
@@ -58,15 +58,7 @@ public IsLessThan<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsLessThan::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @param <R> type of the new condition
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsLessThan<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsLessThan::new, IsLessThan::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLessThanOrEqualTo.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLessThanOrEqualTo.java
@@ -58,15 +58,7 @@ public IsLessThanOrEqualTo<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsLessThanOrEqualTo::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @param <R> type of the new condition
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsLessThanOrEqualTo<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsLessThanOrEqualTo::new, IsLessThanOrEqualTo::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLike.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLike.java
@@ -58,15 +58,7 @@ public IsLike<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsLike::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @param <R> type of the new condition
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsLike<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsLike::new, IsLike::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLikeCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsLikeCaseInsensitive.java
@@ -16,15 +16,15 @@
 package org.mybatis.dynamic.sql.where.condition;
 
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractSingleValueCondition;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
-public class IsLikeCaseInsensitive extends AbstractSingleValueCondition<String>
-        implements CaseInsensitiveRenderableCondition {
-    private static final IsLikeCaseInsensitive EMPTY = new IsLikeCaseInsensitive("") { //$NON-NLS-1$
+public class IsLikeCaseInsensitive<T> extends AbstractSingleValueCondition<T>
+        implements CaseInsensitiveRenderableCondition<T> {
+    private static final IsLikeCaseInsensitive<?> EMPTY = new IsLikeCaseInsensitive<>("") { //$NON-NLS-1$
         @Override
         public String value() {
             throw new NoSuchElementException("No value present"); //$NON-NLS-1$
@@ -36,11 +36,13 @@ public boolean isEmpty() {
         }
     };
 
-    public static IsLikeCaseInsensitive empty() {
-        return EMPTY;
+    public static <T> IsLikeCaseInsensitive<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsLikeCaseInsensitive<T> t = (IsLikeCaseInsensitive<T>) EMPTY;
+        return t;
     }
 
-    protected IsLikeCaseInsensitive(String value) {
+    protected IsLikeCaseInsensitive(T value) {
         super(value);
     }
 
@@ -50,25 +52,18 @@ public String operator() {
     }
 
     @Override
-    public IsLikeCaseInsensitive filter(Predicate<? super String> predicate) {
+    public IsLikeCaseInsensitive<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsLikeCaseInsensitive::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
-    public IsLikeCaseInsensitive map(UnaryOperator<String> mapper) {
+    @Override
+    public <R> IsLikeCaseInsensitive<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsLikeCaseInsensitive::new, IsLikeCaseInsensitive::empty);
     }
 
-    public static IsLikeCaseInsensitive of(String value) {
+    public static IsLikeCaseInsensitive<String> of(String value) {
         // Keep the null safe upper case utility for backwards compatibility
         //noinspection DataFlowIssue
-        return new IsLikeCaseInsensitive(value).map(StringUtilities::safelyUpperCase);
+        return new IsLikeCaseInsensitive<>(value).map(StringUtilities::safelyUpperCase);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotEqualTo.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotEqualTo.java
@@ -58,15 +58,7 @@ public IsNotEqualTo<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsNotEqualTo::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper a mapping function to apply to the value, if renderable
-     * @param <R> type of the new condition
-     * @return a new condition with the result of applying the mapper to the value of this condition,
-     *     if renderable, otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsNotEqualTo<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsNotEqualTo::new, IsNotEqualTo::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitive.java
@@ -27,7 +27,7 @@
 import org.mybatis.dynamic.sql.util.Validator;
 
 public class IsNotInCaseInsensitive extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition {
+        implements CaseInsensitiveRenderableCondition<String> {
     private static final IsNotInCaseInsensitive EMPTY = new IsNotInCaseInsensitive(Collections.emptyList());
 
     public static IsNotInCaseInsensitive empty() {
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitiveWhenPresent.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotInCaseInsensitiveWhenPresent.java
@@ -27,7 +27,7 @@
 import org.mybatis.dynamic.sql.util.Utilities;
 
 public class IsNotInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition {
+        implements CaseInsensitiveRenderableCondition<String> {
     private static final IsNotInCaseInsensitiveWhenPresent EMPTY =
             new IsNotInCaseInsensitiveWhenPresent(Collections.emptyList());
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotLike.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotLike.java
@@ -58,18 +58,7 @@ public IsNotLike<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsNotLike::empty, this);
     }
 
-    /**
-     * If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
-     * condition that will not render (this).
-     *
-     * @param mapper
-     *            a mapping function to apply to the value, if renderable
-     * @param <R>
-     *            type of the new condition
-     *
-     * @return a new condition with the result of applying the mapper to the value of this condition, if renderable,
-     *         otherwise a condition that will not render.
-     */
+    @Override
     public <R> IsNotLike<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsNotLike::new, IsNotLike::empty);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotLikeCaseInsensitive.java b/src/main/java/org/mybatis/dynamic/sql/where/condition/IsNotLikeCaseInsensitive.java
@@ -16,15 +16,15 @@
 package org.mybatis.dynamic.sql.where.condition;
 
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractSingleValueCondition;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
-public class IsNotLikeCaseInsensitive extends AbstractSingleValueCondition<String>
-        implements CaseInsensitiveRenderableCondition {
-    private static final IsNotLikeCaseInsensitive EMPTY = new IsNotLikeCaseInsensitive("") { //$NON-NLS-1$
+public class IsNotLikeCaseInsensitive<T> extends AbstractSingleValueCondition<T>
+        implements CaseInsensitiveRenderableCondition<T> {
+    private static final IsNotLikeCaseInsensitive<?> EMPTY = new IsNotLikeCaseInsensitive<>("") { //$NON-NLS-1$
         @Override
         public String value() {
             throw new NoSuchElementException("No value present"); //$NON-NLS-1$
@@ -36,11 +36,13 @@ public boolean isEmpty() {
         }
     };
 
-    public static IsNotLikeCaseInsensitive empty() {
-        return EMPTY;
+    public static <T> IsNotLikeCaseInsensitive<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsNotLikeCaseInsensitive<T> t = (IsNotLikeCaseInsensitive<T>) EMPTY;
+        return t;
     }
 
-    protected IsNotLikeCaseInsensitive(String value) {
+    protected IsNotLikeCaseInsensitive(T value) {
         super(value);
     }
 
@@ -50,7 +52,7 @@ public String operator() {
     }
 
     @Override
-    public IsNotLikeCaseInsensitive filter(Predicate<? super String> predicate) {
+    public IsNotLikeCaseInsensitive<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsNotLikeCaseInsensitive::empty, this);
     }
 
@@ -64,13 +66,13 @@ public IsNotLikeCaseInsensitive filter(Predicate<? super String> predicate) {
      * @return a new condition with the result of applying the mapper to the value of this condition, if renderable,
      *         otherwise a condition that will not render.
      */
-    public IsNotLikeCaseInsensitive map(UnaryOperator<String> mapper) {
+    public <R> IsNotLikeCaseInsensitive<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsNotLikeCaseInsensitive::new, IsNotLikeCaseInsensitive::empty);
     }
 
-    public static IsNotLikeCaseInsensitive of(String value) {
+    public static IsNotLikeCaseInsensitive<String> of(String value) {
         // Keep the null safe upper case utility for backwards compatibility
         //noinspection DataFlowIssue
-        return new IsNotLikeCaseInsensitive(value).map(StringUtilities::safelyUpperCase);
+        return new IsNotLikeCaseInsensitive<>(value).map(StringUtilities::safelyUpperCase);
     }
 }
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt
diff --git a/src/test/java/examples/mysql/IsLikeEscape.java b/src/test/java/examples/mysql/IsLikeEscape.java
diff --git a/src/test/java/org/mybatis/dynamic/sql/where/condition/FilterAndMapTest.java b/src/test/java/org/mybatis/dynamic/sql/where/condition/FilterAndMapTest.java
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/mariadb/KIsLikeEscape.kt b/src/test/kotlin/examples/kotlin/mybatis3/mariadb/KIsLikeEscape.kt

Original file line number	Diff line number	Diff line change
`@@ -882,35 +882,36 @@ static IsEqualTo<Boolean> isFalse() {`
`882`	`882`	`}`
`883`	`883`
`884`	`884`	`// conditions for strings only`
`885`		`- static IsLikeCaseInsensitive isLikeCaseInsensitive(String value) {`
	`885`	`+ static IsLikeCaseInsensitive<String> isLikeCaseInsensitive(String value) {`
`886`	`886`	`return IsLikeCaseInsensitive.of(value);`
`887`	`887`	`}`
`888`	`888`
`889`		`- static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<String> valueSupplier) {`
	`889`	`+ static IsLikeCaseInsensitive<String> isLikeCaseInsensitive(Supplier<String> valueSupplier) {`
`890`	`890`	`return isLikeCaseInsensitive(valueSupplier.get());`
`891`	`891`	`}`
`892`	`892`
`893`		`- static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(@Nullable String value) {`
	`893`	`+ static IsLikeCaseInsensitive<String> isLikeCaseInsensitiveWhenPresent(@Nullable String value) {`
`894`	`894`	`return value == null ? IsLikeCaseInsensitive.empty() : IsLikeCaseInsensitive.of(value);`
`895`	`895`	`}`
`896`	`896`
`897`		`- static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {`
	`897`	`+ static IsLikeCaseInsensitive<String> isLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {`
`898`	`898`	`return isLikeCaseInsensitiveWhenPresent(valueSupplier.get());`
`899`	`899`	`}`
`900`	`900`
`901`		`- static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value) {`
	`901`	`+ static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitive(String value) {`
`902`	`902`	`return IsNotLikeCaseInsensitive.of(value);`
`903`	`903`	`}`
`904`	`904`
`905`		`- static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {`
	`905`	`+ static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {`
`906`	`906`	`return isNotLikeCaseInsensitive(valueSupplier.get());`
`907`	`907`	`}`
`908`	`908`
`909`		`- static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(@Nullable String value) {`
	`909`	`+ static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitiveWhenPresent(@Nullable String value) {`
`910`	`910`	`return value == null ? IsNotLikeCaseInsensitive.empty() : IsNotLikeCaseInsensitive.of(value);`
`911`	`911`	`}`
`912`	`912`
`913`		`- static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {`
	`913`	`+ static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitiveWhenPresent(`
	`914`	`+ Supplier<@Nullable String> valueSupplier) {`
`914`	`915`	`return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());`
`915`	`916`	`}`
`916`	`917`