Map functions can change data types - Two Value Conditions

Author: jeffgbutler

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

@@ -15,12 +15,9 @@
  */
 package org.mybatis.dynamic.sql;
 
-import java.util.function.BiFunction;
-import java.util.function.BiPredicate;
-import java.util.function.Supplier;
-import java.util.function.UnaryOperator;
+import java.util.function.*;
 
-public abstract class AbstractTwoValueCondition<T, S extends AbstractTwoValueCondition<T, S>>
+public abstract class AbstractTwoValueCondition<T>
         implements VisitableCondition<T> {
     protected final T value1;
     protected final T value2;
@@ -43,42 +40,34 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
-    protected S filter(BiPredicate<T, T> predicate, Supplier<S> empty, S self) {
+    protected <S> S filterSupport(BiPredicate<? super T, ? super T> predicate, Supplier<S> empty, S self) {
         if (shouldRender()) {
             return predicate.test(value1, value2) ? self : empty.get();
         } else {
             return self;
         }
     }
 
-    /**
-     * If renderable and the values match the predicate, returns this condition. Else returns a condition
-     *     that will not render.
-     *
-     * @param predicate predicate applied to the values, if renderable
-     * @return this condition if renderable and the values match the predicate, otherwise a condition
-     *     that will not render.
-     */
-    public abstract S filter(BiPredicate<T, T> predicate);
-
-    protected S map(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2, BiFunction<T, T, S> constructor, S self) {
+    protected <R, S> S mapSupport(Function<? super T, ? extends R> mapper1,
+                                 Function<? super T, ? extends R> mapper2,
+                                 BiFunction<R, R, S> constructor,
+                                 Supplier<S> empty) {
         if (shouldRender()) {
             return constructor.apply(mapper1.apply(value1), mapper2.apply(value2));
         } else {
-            return self;
+            return empty.get();
         }
     }
 
     /**
-     * If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
-     *     condition that will not render (this).
+     * If renderable and the values match the predicate, returns this condition. Else returns a condition
+     *     that will not render.
      *
-     * @param mapper1 a mapping function to apply to the first value, if renderable
-     * @param mapper2 a mapping function to apply to the second value, if renderable
-     * @return a new condition with the result of applying the mappers to the values of this condition,
-     *     if renderable, otherwise a condition that will not render.
+     * @param predicate predicate applied to the values, if renderable
+     * @return this condition if renderable and the values match the predicate, otherwise a condition
+     *     that will not render.
      */
-    public abstract S map(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2);
+    public abstract AbstractTwoValueCondition<T> filter(BiPredicate<? super T, ? super T> predicate);
 
     public abstract String renderCondition(String columnName, String placeholder1, String placeholder2);
 }

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

@@ -22,7 +22,7 @@ public interface ConditionVisitor<T, R> {
 
     R visit(AbstractSingleValueCondition<T> condition);
 
-    R visit(AbstractTwoValueCondition<T, ?> condition);
+    R visit(AbstractTwoValueCondition<T> condition);
 
     R visit(AbstractSubselectCondition<T> condition);
 

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

@@ -16,12 +16,13 @@
 package org.mybatis.dynamic.sql.where.condition;
 
 import java.util.function.BiPredicate;
+import java.util.function.Function;
 import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractTwoValueCondition;
 import org.mybatis.dynamic.sql.util.Predicates;
 
-public class IsBetween<T> extends AbstractTwoValueCondition<T, IsBetween<T>> {
+public class IsBetween<T> extends AbstractTwoValueCondition<T> {
     private static final IsBetween<?> EMPTY = new IsBetween<Object>(null, null) {
         @Override
         public boolean shouldRender() {
@@ -62,7 +63,7 @@ public IsBetween<T> when(BiPredicate<T, T> predicate) {
      * If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
      *     condition that will not render (this).
      *
-     * @deprecated replaced by {@link IsBetween#map(UnaryOperator, UnaryOperator)}
+     * @deprecated replaced by {@link IsBetween#map(Function, Function)}
      * @param mapper1 a mapping function to apply to the first value, if renderable
      * @param mapper2 a mapping function to apply to the second value, if renderable
      * @return a new condition with the result of applying the mappers to the values of this condition,
@@ -74,13 +75,22 @@ public IsBetween<T> then(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2) {
     }
 
     @Override
-    public IsBetween<T> filter(BiPredicate<T, T> predicate) {
-        return filter(predicate, IsBetween::empty, this);
+    public IsBetween<T> filter(BiPredicate<? super T, ? super T> predicate) {
+        return filterSupport(predicate, IsBetween::empty, this);
     }
 
-    @Override
-    public IsBetween<T> map(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2) {
-        return map(mapper1, mapper2, IsBetween::new, this);
+    /**
+     * If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
+     *     condition that will not render (this).
+     *
+     * @param mapper1 a mapping function to apply to the first value, if renderable
+     * @param mapper2 a mapping function to apply to the second value, if renderable
+     * @param <R> type of the new condition
+     * @return a new condition with the result of applying the mappers to the values of this condition,
+     *     if renderable, otherwise a condition that will not render.
+     */
+    public <R> IsBetween<R> map(Function<? super T, ? extends R> mapper1, Function<? super T, ? extends R> mapper2) {
+        return mapSupport(mapper1, mapper2, IsBetween::new, IsBetween::empty);
     }
 
     public static <T> Builder<T> isBetween(T value1) {

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

@@ -16,12 +16,13 @@
 package org.mybatis.dynamic.sql.where.condition;
 
 import java.util.function.BiPredicate;
+import java.util.function.Function;
 import java.util.function.UnaryOperator;
 
 import org.mybatis.dynamic.sql.AbstractTwoValueCondition;
 import org.mybatis.dynamic.sql.util.Predicates;
 
-public class IsNotBetween<T> extends AbstractTwoValueCondition<T, IsNotBetween<T>> {
+public class IsNotBetween<T> extends AbstractTwoValueCondition<T> {
     private static final IsNotBetween<?> EMPTY = new IsNotBetween<Object>(null, null) {
         @Override
         public boolean shouldRender() {
@@ -62,7 +63,7 @@ public IsNotBetween<T> when(BiPredicate<T, T> predicate) {
      * If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
      *     condition that will not render (this).
      *
-     * @deprecated replaced by {@link IsNotBetween#map(UnaryOperator, UnaryOperator)}
+     * @deprecated replaced by {@link IsNotBetween#map(Function, Function)}
      * @param mapper1 a mapping function to apply to the first value, if renderable
      * @param mapper2 a mapping function to apply to the second value, if renderable
      * @return a new condition with the result of applying the mappers to the values of this condition,
@@ -74,13 +75,23 @@ public IsNotBetween<T> then(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2)
     }
 
     @Override
-    public IsNotBetween<T> filter(BiPredicate<T, T> predicate) {
-        return filter(predicate, IsNotBetween::empty, this);
+    public IsNotBetween<T> filter(BiPredicate<? super T, ? super T> predicate) {
+        return filterSupport(predicate, IsNotBetween::empty, this);
     }
 
-    @Override
-    public IsNotBetween<T> map(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2) {
-        return map(mapper1, mapper2, IsNotBetween::new, this);
+    /**
+     * If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
+     *     condition that will not render (this).
+     *
+     * @param mapper1 a mapping function to apply to the first value, if renderable
+     * @param mapper2 a mapping function to apply to the second value, if renderable
+     * @param <R> type of the new condition
+     * @return a new condition with the result of applying the mappers to the values of this condition,
+     *     if renderable, otherwise a condition that will not render.
+     */
+    public <R> IsNotBetween<R> map(Function<? super T, ? extends R> mapper1,
+                                   Function<? super T, ? extends R> mapper2) {
+        return mapSupport(mapper1, mapper2, IsNotBetween::new, IsNotBetween::empty);
     }
 
     public static <T> Builder<T> isNotBetween(T value1) {

src/main/java/org/mybatis/dynamic/sql/where/render/WhereConditionVisitor.java

@@ -77,7 +77,7 @@ public FragmentAndParameters visit(AbstractSingleValueCondition<T> condition) {
     }
 
     @Override
-    public FragmentAndParameters visit(AbstractTwoValueCondition<T, ?> condition) {
+    public FragmentAndParameters visit(AbstractTwoValueCondition<T> condition) {
         String mapKey1 = RenderingStrategy.formatParameterMapKey(sequence);
         String mapKey2 = RenderingStrategy.formatParameterMapKey(sequence);
         String fragment = condition.renderCondition(columnName(),