Define a map template method for list value

Author: jeffgbutler

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

@@ -83,6 +83,16 @@ protected <R, S extends AbstractListValueCondition<R>> S mapSupport(Function<? s
      */
     public abstract AbstractListValueCondition<T> filter(Predicate<? super T> predicate);
 
+    /**
+     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return an empty condition (this).
+     *
+     * @param mapper a mapping function to apply to the values, if not empty
+     * @param <R> type of the new condition
+     * @return a new condition with mapped values if renderable, otherwise an empty condition
+     */
+    public abstract <R> AbstractListValueCondition<R> map(Function<? super T, ? extends R> mapper);
+
     public abstract String operator();
 
     @Override

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

@@ -915,36 +915,36 @@ static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitiveWhenPresent(
         return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 
-    static IsInCaseInsensitive isInCaseInsensitive(String... values) {
+    static IsInCaseInsensitive<String> isInCaseInsensitive(String... values) {
         return IsInCaseInsensitive.of(values);
     }
 
-    static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {
+    static IsInCaseInsensitive<String> isInCaseInsensitive(Collection<String> values) {
         return IsInCaseInsensitive.of(values);
     }
 
-    static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(@Nullable String... values) {
+    static IsInCaseInsensitiveWhenPresent<String> isInCaseInsensitiveWhenPresent(@Nullable String... values) {
         return IsInCaseInsensitiveWhenPresent.of(values);
     }
 
-    static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(
+    static IsInCaseInsensitiveWhenPresent<String> isInCaseInsensitiveWhenPresent(
             @Nullable Collection<@Nullable String> values) {
         return values == null ? IsInCaseInsensitiveWhenPresent.empty() : IsInCaseInsensitiveWhenPresent.of(values);
     }
 
-    static IsNotInCaseInsensitive isNotInCaseInsensitive(String... values) {
+    static IsNotInCaseInsensitive<String> isNotInCaseInsensitive(String... values) {
         return IsNotInCaseInsensitive.of(values);
     }
 
-    static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values) {
+    static IsNotInCaseInsensitive<String> isNotInCaseInsensitive(Collection<String> values) {
         return IsNotInCaseInsensitive.of(values);
     }
 
-    static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(@Nullable String... values) {
+    static IsNotInCaseInsensitiveWhenPresent<String> isNotInCaseInsensitiveWhenPresent(@Nullable String... values) {
         return IsNotInCaseInsensitiveWhenPresent.of(values);
     }
 
-    static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(
+    static IsNotInCaseInsensitiveWhenPresent<String> isNotInCaseInsensitiveWhenPresent(
             @Nullable Collection<@Nullable String> values) {
         return values == null ? IsNotInCaseInsensitiveWhenPresent.empty() :
                 IsNotInCaseInsensitiveWhenPresent.of(values);

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

@@ -54,14 +54,7 @@ public IsIn<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsIn::new, this, IsIn::empty);
     }
 
-    /**
-     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
-     *     Else return an empty condition (this).
-     *
-     * @param mapper a mapping function to apply to the values, if not empty
-     * @param <R> type of the new condition
-     * @return a new condition with mapped values if renderable, otherwise an empty condition
-     */
+    @Override
     public <R> IsIn<R> map(Function<? super T, ? extends R> mapper) {
         Function<Collection<R>, IsIn<R>> constructor = IsIn::new;
         return mapSupport(mapper, constructor, IsIn::empty);

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

@@ -18,23 +18,25 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Validator;
 
-public class IsInCaseInsensitive extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition<String> {
-    private static final IsInCaseInsensitive EMPTY = new IsInCaseInsensitive(Collections.emptyList());
+public class IsInCaseInsensitive<T> extends AbstractListValueCondition<T>
+        implements CaseInsensitiveRenderableCondition<T> {
+    private static final IsInCaseInsensitive<?> EMPTY = new IsInCaseInsensitive<>(Collections.emptyList());
 
-    public static IsInCaseInsensitive empty() {
-        return EMPTY;
+    public static <T> IsInCaseInsensitive<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsInCaseInsensitive<T> t = (IsInCaseInsensitive<T>) EMPTY;
+        return t;
     }
 
-    protected IsInCaseInsensitive(Collection<String> values) {
+    protected IsInCaseInsensitive(Collection<T> values) {
         super(values);
     }
 
@@ -50,28 +52,22 @@ public String operator() {
     }
 
     @Override
-    public IsInCaseInsensitive filter(Predicate<? super String> predicate) {
+    public IsInCaseInsensitive<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsInCaseInsensitive::new, this, IsInCaseInsensitive::empty);
     }
 
-    /**
-     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
-     *     Else return an empty condition (this).
-     *
-     * @param mapper a mapping function to apply to the values, if not empty
-     * @return a new condition with mapped values if renderable, otherwise an empty condition
-     */
-    public IsInCaseInsensitive map(UnaryOperator<String> mapper) {
+    @Override
+    public <R> IsInCaseInsensitive<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsInCaseInsensitive::new, IsInCaseInsensitive::empty);
     }
 
-    public static IsInCaseInsensitive of(String... values) {
+    public static IsInCaseInsensitive<String> of(String... values) {
         return of(Arrays.asList(values));
     }
 
-    public static IsInCaseInsensitive of(Collection<String> values) {
+    public static IsInCaseInsensitive<String> of(Collection<String> values) {
         // Keep the null safe upper case utility for backwards compatibility
         //noinspection DataFlowIssue
-        return new IsInCaseInsensitive(values).map(StringUtilities::safelyUpperCase);
+        return new IsInCaseInsensitive<>(values).map(StringUtilities::safelyUpperCase);
     }
 }

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

@@ -18,24 +18,26 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
 
 import org.jspecify.annotations.Nullable;
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Utilities;
 
-public class IsInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition<String> {
-    private static final IsInCaseInsensitiveWhenPresent EMPTY =
-            new IsInCaseInsensitiveWhenPresent(Collections.emptyList());
+public class IsInCaseInsensitiveWhenPresent<T> extends AbstractListValueCondition<T>
+        implements CaseInsensitiveRenderableCondition<T> {
+    private static final IsInCaseInsensitiveWhenPresent<?> EMPTY =
+            new IsInCaseInsensitiveWhenPresent<>(Collections.emptyList());
 
-    public static IsInCaseInsensitiveWhenPresent empty() {
-        return EMPTY;
+    public static <T> IsInCaseInsensitiveWhenPresent<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsInCaseInsensitiveWhenPresent<T> t = (IsInCaseInsensitiveWhenPresent<T>) EMPTY;
+        return t;
     }
 
-    protected IsInCaseInsensitiveWhenPresent(Collection<@Nullable String> values) {
+    protected IsInCaseInsensitiveWhenPresent(Collection<@Nullable T> values) {
         super(Utilities.removeNullElements(values));
     }
 
@@ -45,29 +47,23 @@ public String operator() {
     }
 
     @Override
-    public IsInCaseInsensitiveWhenPresent filter(Predicate<? super String> predicate) {
+    public IsInCaseInsensitiveWhenPresent<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsInCaseInsensitiveWhenPresent::new, this,
                 IsInCaseInsensitiveWhenPresent::empty);
     }
 
-    /**
-     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
-     *     Else return an empty condition (this).
-     *
-     * @param mapper a mapping function to apply to the values, if not empty
-     * @return a new condition with mapped values if renderable, otherwise an empty condition
-     */
-    public IsInCaseInsensitiveWhenPresent map(UnaryOperator<String> mapper) {
+    @Override
+    public <R> IsInCaseInsensitiveWhenPresent<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsInCaseInsensitiveWhenPresent::new, IsInCaseInsensitiveWhenPresent::empty);
     }
 
-    public static IsInCaseInsensitiveWhenPresent of(@Nullable String... values) {
+    public static IsInCaseInsensitiveWhenPresent<String> of(@Nullable String... values) {
         return of(Arrays.asList(values));
     }
 
-    public static IsInCaseInsensitiveWhenPresent of(Collection<@Nullable String> values) {
+    public static IsInCaseInsensitiveWhenPresent<String> of(Collection<@Nullable String> values) {
         // Keep the null safe upper case utility for backwards compatibility
         //noinspection DataFlowIssue
-        return new IsInCaseInsensitiveWhenPresent(values).map(StringUtilities::safelyUpperCase);
+        return new IsInCaseInsensitiveWhenPresent<>(values).map(StringUtilities::safelyUpperCase);
     }
 }

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

@@ -54,14 +54,7 @@ public IsNotIn<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsNotIn::new, this, IsNotIn::empty);
     }
 
-    /**
-     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
-     *     Else return an empty condition (this).
-     *
-     * @param mapper a mapping function to apply to the values, if not empty
-     * @param <R> type of the new condition
-     * @return a new condition with mapped values if renderable, otherwise an empty condition
-     */
+    @Override
     public <R> IsNotIn<R> map(Function<? super T, ? extends R> mapper) {
         Function<Collection<R>, IsNotIn<R>> constructor = IsNotIn::new;
         return mapSupport(mapper, constructor, IsNotIn::empty);

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

@@ -18,23 +18,25 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Validator;
 
-public class IsNotInCaseInsensitive extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition<String> {
-    private static final IsNotInCaseInsensitive EMPTY = new IsNotInCaseInsensitive(Collections.emptyList());
+public class IsNotInCaseInsensitive<T> extends AbstractListValueCondition<T>
+        implements CaseInsensitiveRenderableCondition<T> {
+    private static final IsNotInCaseInsensitive<?> EMPTY = new IsNotInCaseInsensitive<>(Collections.emptyList());
 
-    public static IsNotInCaseInsensitive empty() {
-        return EMPTY;
+    public static <T> IsNotInCaseInsensitive<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsNotInCaseInsensitive<T> t = (IsNotInCaseInsensitive<T>) EMPTY;
+        return t;
     }
 
-    protected IsNotInCaseInsensitive(Collection<String> values) {
+    protected IsNotInCaseInsensitive(Collection<T> values) {
         super(values);
     }
 
@@ -50,28 +52,22 @@ public String operator() {
     }
 
     @Override
-    public IsNotInCaseInsensitive filter(Predicate<? super String> predicate) {
+    public IsNotInCaseInsensitive<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsNotInCaseInsensitive::new, this, IsNotInCaseInsensitive::empty);
     }
 
-    /**
-     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
-     *     Else return an empty condition (this).
-     *
-     * @param mapper a mapping function to apply to the values, if not empty
-     * @return a new condition with mapped values if renderable, otherwise an empty condition
-     */
-    public IsNotInCaseInsensitive map(UnaryOperator<String> mapper) {
+    @Override
+    public <R> IsNotInCaseInsensitive<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsNotInCaseInsensitive::new, IsNotInCaseInsensitive::empty);
     }
 
-    public static IsNotInCaseInsensitive of(String... values) {
+    public static IsNotInCaseInsensitive<String> of(String... values) {
         return of(Arrays.asList(values));
     }
 
-    public static IsNotInCaseInsensitive of(Collection<String> values) {
+    public static IsNotInCaseInsensitive<String> of(Collection<String> values) {
         // Keep the null safe upper case utility for backwards compatibility
         //noinspection DataFlowIssue
-        return new IsNotInCaseInsensitive(values).map(StringUtilities::safelyUpperCase);
+        return new IsNotInCaseInsensitive<>(values).map(StringUtilities::safelyUpperCase);
     }
 }

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

@@ -18,24 +18,26 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
 
 import org.jspecify.annotations.Nullable;
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 import org.mybatis.dynamic.sql.util.Utilities;
 
-public class IsNotInCaseInsensitiveWhenPresent extends AbstractListValueCondition<String>
-        implements CaseInsensitiveRenderableCondition<String> {
-    private static final IsNotInCaseInsensitiveWhenPresent EMPTY =
-            new IsNotInCaseInsensitiveWhenPresent(Collections.emptyList());
+public class IsNotInCaseInsensitiveWhenPresent<T> extends AbstractListValueCondition<T>
+        implements CaseInsensitiveRenderableCondition<T> {
+    private static final IsNotInCaseInsensitiveWhenPresent<?> EMPTY =
+            new IsNotInCaseInsensitiveWhenPresent<>(Collections.emptyList());
 
-    public static IsNotInCaseInsensitiveWhenPresent empty() {
-        return EMPTY;
+    public static <T> IsNotInCaseInsensitiveWhenPresent<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsNotInCaseInsensitiveWhenPresent<T> t = (IsNotInCaseInsensitiveWhenPresent<T>) EMPTY;
+        return t;
     }
 
-    protected IsNotInCaseInsensitiveWhenPresent(Collection<@Nullable String> values) {
+    protected IsNotInCaseInsensitiveWhenPresent(Collection<@Nullable T> values) {
         super(Utilities.removeNullElements(values));
     }
 
@@ -45,29 +47,23 @@ public String operator() {
     }
 
     @Override
-    public IsNotInCaseInsensitiveWhenPresent filter(Predicate<? super String> predicate) {
+    public IsNotInCaseInsensitiveWhenPresent<T> filter(Predicate<? super T> predicate) {
         return filterSupport(predicate, IsNotInCaseInsensitiveWhenPresent::new,
                 this, IsNotInCaseInsensitiveWhenPresent::empty);
     }
 
-    /**
-     * If not empty, apply the mapping to each value in the list return a new condition with the mapped values.
-     *     Else return an empty condition (this).
-     *
-     * @param mapper a mapping function to apply to the values, if not empty
-     * @return a new condition with mapped values if renderable, otherwise an empty condition
-     */
-    public IsNotInCaseInsensitiveWhenPresent map(UnaryOperator<String> mapper) {
+    @Override
+    public <R> IsNotInCaseInsensitiveWhenPresent<R> map(Function<? super T, ? extends R> mapper) {
         return mapSupport(mapper, IsNotInCaseInsensitiveWhenPresent::new, IsNotInCaseInsensitiveWhenPresent::empty);
     }
 
-    public static IsNotInCaseInsensitiveWhenPresent of(@Nullable String... values) {
+    public static IsNotInCaseInsensitiveWhenPresent<String> of(@Nullable String... values) {
         return of(Arrays.asList(values));
     }
 
-    public static IsNotInCaseInsensitiveWhenPresent of(Collection<@Nullable String> values) {
+    public static IsNotInCaseInsensitiveWhenPresent<String> of(Collection<@Nullable String> values) {
         // Keep the null safe upper case utility for backwards compatibility
         //noinspection DataFlowIssue
-        return new IsNotInCaseInsensitiveWhenPresent(values).map(StringUtilities::safelyUpperCase);
+        return new IsNotInCaseInsensitiveWhenPresent<>(values).map(StringUtilities::safelyUpperCase);
     }
 }