Map functions can change data types - List Value Conditions

Author: jeffgbutler

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

@@ -17,14 +17,11 @@
 
 import java.util.Collection;
 import java.util.Objects;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
+import java.util.function.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public abstract class AbstractListValueCondition<T, S extends AbstractListValueCondition<T, S>>
+public abstract class AbstractListValueCondition<T>
         implements VisitableCondition<T> {
     protected final Collection<T> values;
     protected final Callback emptyCallback;
@@ -57,54 +54,47 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
-    private Collection<T> applyMapper(UnaryOperator<T> mapper) {
+    private <R> Collection<R> applyMapper(Function<? super T, ? extends R> mapper) {
         Objects.requireNonNull(mapper);
         return values.stream().map(mapper).collect(Collectors.toList());
     }
 
-    private Collection<T> applyFilter(Predicate<T> predicate) {
+    private Collection<T> applyFilter(Predicate<? super T> predicate) {
         Objects.requireNonNull(predicate);
         return values.stream().filter(predicate).collect(Collectors.toList());
     }
 
-    protected S filter(Predicate<T> predicate, BiFunction<Collection<T>, Callback, S> constructor, S self) {
+    protected <S> S filterSupport(Predicate<? super T> predicate,
+            BiFunction<Collection<T>, Callback, S> constructor, S self, Supplier<S> empty) {
         if (shouldRender()) {
-            return constructor.apply(applyFilter(predicate), emptyCallback);
+            Collection<T> filtered = applyFilter(predicate);
+            return filtered.isEmpty() ? empty.get() : constructor.apply(filtered, emptyCallback);
         } else {
             return self;
         }
     }
 
-    /**
-     * If renderable, apply the predicate to each value in the list and return a new condition with the filtered values.
-     *     Else returns a condition that will not render (this). If all values are filtered out of the value
-     *     list, then the condition will not render.
-     *
-     * @param predicate predicate applied to the values, if renderable
-     * @return a new condition with filtered values if renderable, otherwise a condition
-     *     that will not render.
-     */
-    public abstract S filter(Predicate<T> predicate);
-
-    protected S map(UnaryOperator<T> mapper, BiFunction<Collection<T>, Callback, S> constructor, S self) {
+    protected <R, S> S mapSupport(Function<? super T, ? extends R> mapper,
+            BiFunction<Collection<R>, Callback, S> constructor, Supplier<S> empty) {
         if (shouldRender()) {
             return constructor.apply(applyMapper(mapper), emptyCallback);
         } else {
-            return self;
+            return empty.get();
         }
     }
 
     /**
-     * If renderable, apply the mapping to each value in the list return a new condition with the mapped values.
-     *     Else return a condition that will not render (this).
+     * If renderable, apply the predicate to each value in the list and return a new condition with the filtered values.
+     *     Else returns a condition that will not render (this). If all values are filtered out of the value
+     *     list, then the condition will not render.
      *
-     * @param mapper a mapping function to apply to the values, if renderable
-     * @return a new condition with mapped values if renderable, otherwise a condition
+     * @param predicate predicate applied to the values, if renderable
+     * @return a new condition with filtered values if renderable, otherwise a condition
      *     that will not render.
      */
-    public abstract S map(UnaryOperator<T> mapper);
+    public abstract AbstractListValueCondition<T> filter(Predicate<? super T> predicate);
 
-    public abstract S withListEmptyCallback(Callback callback);
+    public abstract AbstractListValueCondition<T> withListEmptyCallback(Callback callback);
 
     public abstract String renderCondition(String columnName, Stream<String> placeholders);
 }

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

@@ -16,7 +16,7 @@
 package org.mybatis.dynamic.sql;
 
 public interface ConditionVisitor<T, R> {
-    R visit(AbstractListValueCondition<T, ?> condition);
+    R visit(AbstractListValueCondition<T> condition);
 
     R visit(AbstractNoValueCondition<T> condition);
 

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

@@ -19,7 +19,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
@@ -28,7 +30,14 @@
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.Callback;
 
-public class IsIn<T> extends AbstractListValueCondition<T, IsIn<T>> {
+public class IsIn<T> extends AbstractListValueCondition<T> {
+    private static final IsIn<?> EMPTY = new IsIn<>(Collections.emptyList());
+
+    public static <T> IsIn<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsIn<T> t = (IsIn<T>) EMPTY;
+        return t;
+    }
 
     protected IsIn(Collection<T> values) {
         super(values);
@@ -55,7 +64,7 @@ public IsIn<T> withListEmptyCallback(Callback callback) {
      * If you filter values out of the stream, then final condition will not reference those values. If you filter all
      * values out of the stream, then the condition will not render.
      *
-     * @deprecated replaced by {@link IsIn#map(UnaryOperator)} and {@link IsIn#filter(Predicate)}
+     * @deprecated replaced by {@link IsIn#map(Function)} and {@link IsIn#filter(Predicate)}
      * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
      *     the values are placed in the parameter map
      * @return new condition with the specified transformer
@@ -68,13 +77,21 @@ public IsIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
     }
 
     @Override
-    public IsIn<T> filter(Predicate<T> predicate) {
-        return filter(predicate, IsIn::new, this);
+    public IsIn<T> filter(Predicate<? super T> predicate) {
+        return filterSupport(predicate, IsIn::new, this, IsIn::empty);
     }
 
-    @Override
-    public IsIn<T> map(UnaryOperator<T> mapper) {
-        return map(mapper, IsIn::new, this);
+    /**
+     * If renderable, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return a condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to the values, if renderable
+     * @param <R> type of the new condition
+     * @return a new condition with mapped values if renderable, otherwise a condition
+     *     that will not render.
+     */
+    public <R> IsIn<R> map(Function<? super T, ? extends R> mapper) {
+        return mapSupport(mapper, IsIn::new, IsIn::empty);
     }
 
     @SafeVarargs

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

@@ -17,6 +17,7 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
@@ -26,7 +27,12 @@
 import org.mybatis.dynamic.sql.Callback;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
-public class IsInCaseInsensitive extends AbstractListValueCondition<String, IsInCaseInsensitive> {
+public class IsInCaseInsensitive extends AbstractListValueCondition<String> {
+    private static final IsInCaseInsensitive EMPTY = new IsInCaseInsensitive(Collections.emptyList());
+
+    public static IsInCaseInsensitive empty() {
+        return EMPTY;
+    }
 
     protected  IsInCaseInsensitive(Collection<String> values) {
         super(values);
@@ -48,13 +54,20 @@ public IsInCaseInsensitive withListEmptyCallback(Callback callback) {
     }
 
     @Override
-    public IsInCaseInsensitive filter(Predicate<String> predicate) {
-        return filter(predicate, IsInCaseInsensitive::new, this);
+    public IsInCaseInsensitive filter(Predicate<? super String> predicate) {
+        return filterSupport(predicate, IsInCaseInsensitive::new, this, IsInCaseInsensitive::empty);
     }
 
-    @Override
+    /**
+     * If renderable, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return a condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to the values, if renderable
+     * @return a new condition with mapped values if renderable, otherwise a condition
+     *     that will not render.
+     */
     public IsInCaseInsensitive map(UnaryOperator<String> mapper) {
-        return map(mapper, IsInCaseInsensitive::new, this);
+        return mapSupport(mapper, IsInCaseInsensitive::new, IsInCaseInsensitive::empty);
     }
 
     public static IsInCaseInsensitive of(String... values) {

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

@@ -19,7 +19,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
@@ -28,7 +30,14 @@
 import org.mybatis.dynamic.sql.AbstractListValueCondition;
 import org.mybatis.dynamic.sql.Callback;
 
-public class IsNotIn<T> extends AbstractListValueCondition<T, IsNotIn<T>> {
+public class IsNotIn<T> extends AbstractListValueCondition<T> {
+    private static final IsNotIn<?> EMPTY = new IsNotIn<>(Collections.emptyList());
+
+    public static <T> IsNotIn<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsNotIn<T> t = (IsNotIn<T>) EMPTY;
+        return t;
+    }
 
     protected IsNotIn(Collection<T> values) {
         super(values);
@@ -56,7 +65,7 @@ public IsNotIn<T> withListEmptyCallback(Callback callback) {
      * If you filter values out of the stream, then final condition will not reference those values. If you filter all
      * values out of the stream, then the condition will not render.
      *
-     * @deprecated replaced by {@link IsNotIn#map(UnaryOperator)} and {@link IsNotIn#filter(Predicate)}
+     * @deprecated replaced by {@link IsNotIn#map(Function)} and {@link IsNotIn#filter(Predicate)}
      * @param valueStreamTransformer a UnaryOperator that will transform the value stream before
      *     the values are placed in the parameter map
      * @return new condition with the specified transformer
@@ -70,13 +79,21 @@ public IsNotIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
     }
 
     @Override
-    public IsNotIn<T> filter(Predicate<T> predicate) {
-        return filter(predicate, IsNotIn::new, this);
+    public IsNotIn<T> filter(Predicate<? super T> predicate) {
+        return filterSupport(predicate, IsNotIn::new, this, IsNotIn::empty);
     }
 
-    @Override
-    public IsNotIn<T> map(UnaryOperator<T> mapper) {
-        return map(mapper, IsNotIn::new, this);
+    /**
+     * If renderable, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return a condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to the values, if renderable
+     * @param <R> type of the new condition
+     * @return a new condition with mapped values if renderable, otherwise a condition
+     *     that will not render.
+     */
+    public <R> IsNotIn<R> map(Function<? super T, ? extends R> mapper) {
+        return mapSupport(mapper, IsNotIn::new, IsNotIn::empty);
     }
 
     @SafeVarargs

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

@@ -17,6 +17,7 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
@@ -26,7 +27,12 @@
 import org.mybatis.dynamic.sql.Callback;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
-public class IsNotInCaseInsensitive extends AbstractListValueCondition<String, IsNotInCaseInsensitive> {
+public class IsNotInCaseInsensitive extends AbstractListValueCondition<String> {
+    private static final IsNotInCaseInsensitive EMPTY = new IsNotInCaseInsensitive(Collections.emptyList());
+
+    public static IsNotInCaseInsensitive empty() {
+        return EMPTY;
+    }
 
     protected IsNotInCaseInsensitive(Collection<String> values) {
         super(values);
@@ -49,13 +55,20 @@ public IsNotInCaseInsensitive withListEmptyCallback(Callback callback) {
     }
 
     @Override
-    public IsNotInCaseInsensitive filter(Predicate<String> predicate) {
-        return filter(predicate, IsNotInCaseInsensitive::new, this);
+    public IsNotInCaseInsensitive filter(Predicate<? super String> predicate) {
+        return filterSupport(predicate, IsNotInCaseInsensitive::new, this, IsNotInCaseInsensitive::empty);
     }
 
-    @Override
+    /**
+     * If renderable, apply the mapping to each value in the list return a new condition with the mapped values.
+     *     Else return a condition that will not render (this).
+     *
+     * @param mapper a mapping function to apply to the values, if renderable
+     * @return a new condition with mapped values if renderable, otherwise a condition
+     *     that will not render.
+     */
     public IsNotInCaseInsensitive map(UnaryOperator<String> mapper) {
-        return map(mapper, IsNotInCaseInsensitive::new, this);
+        return mapSupport(mapper, IsNotInCaseInsensitive::new, IsNotInCaseInsensitive::empty);
     }
 
     public static IsNotInCaseInsensitive of(String... values) {

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

@@ -50,7 +50,7 @@ private WhereConditionVisitor(Builder<T> builder) {
     }
 
     @Override
-    public FragmentAndParameters visit(AbstractListValueCondition<T, ?> condition) {
+    public FragmentAndParameters visit(AbstractListValueCondition<T> condition) {
         FragmentCollector fc = condition.mapValues(this::toFragmentAndParameters)
                 .collect(FragmentCollector.collect());