Define a map template method for single value

Author: jeffgbutler

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

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());
     }
 

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$
     }

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);
     }

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);
     }

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);
     }

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() {

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());
 

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);
     }

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);
     }

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);
     }

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);
     }
 }

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);
     }

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() {

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());
 

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);
     }

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);
     }
 }