Refactor filter/map algorithm into base class for List Conditions

Author: jeffgbutler

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

@@ -17,6 +17,7 @@
 
 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;
@@ -56,16 +57,53 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
-    protected Collection<T> applyMapper(UnaryOperator<T> mapper) {
+    private Collection<T> applyMapper(UnaryOperator<T> mapper) {
         Objects.requireNonNull(mapper);
         return values.stream().map(mapper).collect(Collectors.toList());
     }
 
-    protected Collection<T> applyFilter(Predicate<T> predicate) {
+    private Collection<T> applyFilter(Predicate<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) {
+        if (shouldRender()) {
+            return constructor.apply(applyFilter(predicate), emptyCallback);
+        } else {
+            return self;
+        }
+    }
+
+    protected S map(UnaryOperator<T> mapper, BiFunction<Collection<T>, Callback, S> constructor, S self) {
+        if (shouldRender()) {
+            return constructor.apply(applyMapper(mapper), 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);
+
+    /**
+     * 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 abstract S map(UnaryOperator<T> mapper);
+
     public abstract S withListEmptyCallback(Callback callback);
 
     public abstract String renderCondition(String columnName, Stream<String> placeholders);

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

@@ -67,37 +67,14 @@ public IsIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
         return new IsIn<>(mapped, emptyCallback);
     }
 
-    /**
-     * 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.
-     */
+    @Override
     public IsIn<T> filter(Predicate<T> predicate) {
-        if (shouldRender()) {
-            return new IsIn<>(applyFilter(predicate), emptyCallback);
-        } else {
-            return this;
-        }
+        return filter(predicate, 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
-     * @return a new condition with mapped values if renderable, otherwise a condition
-     *     that will not render.
-     */
+    @Override
     public IsIn<T> map(UnaryOperator<T> mapper) {
-        if (shouldRender()) {
-            return new IsIn<>(applyMapper(mapper), emptyCallback);
-        } else {
-            return this;
-        }
+        return map(mapper, IsIn::new, this);
     }
 
     @SafeVarargs

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

@@ -47,37 +47,14 @@ public IsInCaseInsensitive withListEmptyCallback(Callback callback) {
         return new IsInCaseInsensitive(values, callback);
     }
 
-    /**
-     * 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.
-     */
+    @Override
     public IsInCaseInsensitive filter(Predicate<String> predicate) {
-        if (shouldRender()) {
-            return new IsInCaseInsensitive(applyFilter(predicate), emptyCallback);
-        } else {
-            return this;
-        }
+        return filter(predicate, IsInCaseInsensitive::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
-     * @return a new condition with mapped values if renderable, otherwise a condition
-     *     that will not render.
-     */
+    @Override
     public IsInCaseInsensitive map(UnaryOperator<String> mapper) {
-        if (shouldRender()) {
-            return new IsInCaseInsensitive(applyMapper(mapper), emptyCallback);
-        } else {
-            return this;
-        }
+        return map(mapper, IsInCaseInsensitive::new, this);
     }
 
     public static IsInCaseInsensitive of(String... values) {

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

@@ -69,37 +69,14 @@ public IsNotIn<T> then(UnaryOperator<Stream<T>> valueStreamTransformer) {
         return new IsNotIn<>(mapped, emptyCallback);
     }
 
-    /**
-     * 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.
-     */
+    @Override
     public IsNotIn<T> filter(Predicate<T> predicate) {
-        if (shouldRender()) {
-            return new IsNotIn<>(applyFilter(predicate), emptyCallback);
-        } else {
-            return this;
-        }
+        return filter(predicate, 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
-     * @return a new condition with mapped values if renderable, otherwise a condition
-     *     that will not render.
-     */
+    @Override
     public IsNotIn<T> map(UnaryOperator<T> mapper) {
-        if (shouldRender()) {
-            return new IsNotIn<>(applyMapper(mapper), emptyCallback);
-        } else {
-            return this;
-        }
+        return map(mapper, IsNotIn::new, this);
     }
 
     @SafeVarargs

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

@@ -48,37 +48,14 @@ public IsNotInCaseInsensitive withListEmptyCallback(Callback callback) {
         return new IsNotInCaseInsensitive(values, callback);
     }
 
-    /**
-     * 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.
-     */
+    @Override
     public IsNotInCaseInsensitive filter(Predicate<String> predicate) {
-        if (shouldRender()) {
-            return new IsNotInCaseInsensitive(applyFilter(predicate), emptyCallback);
-        } else {
-            return this;
-        }
+        return filter(predicate, IsNotInCaseInsensitive::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
-     * @return a new condition with mapped values if renderable, otherwise a condition
-     *     that will not render.
-     */
+    @Override
     public IsNotInCaseInsensitive map(UnaryOperator<String> mapper) {
-        if (shouldRender()) {
-            return new IsNotInCaseInsensitive(applyMapper(mapper), emptyCallback);
-        } else {
-            return this;
-        }
+        return map(mapper, IsNotInCaseInsensitive::new, this);
     }
 
     public static IsNotInCaseInsensitive of(String... values) {