Merge pull request #333 from jeffgbutler/further-refactoring

Further Condition Refactoring

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;
+        }
+    }
+
+    /**
+     * 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) {
+        if (shouldRender()) {
+            return constructor.apply(applyMapper(mapper), emptyCallback);
+        } else {
+            return self;
+        }
+    }
+
+    /**
+     * 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/AbstractNoValueCondition.java

@@ -15,12 +15,23 @@
  */
 package org.mybatis.dynamic.sql;
 
+import java.util.function.BooleanSupplier;
+import java.util.function.Supplier;
+
 public abstract class AbstractNoValueCondition<T> implements VisitableCondition<T> {
 
     @Override
     public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
+    protected <S> S filter(BooleanSupplier booleanSupplier, Supplier<S> empty, S self) {
+        if (shouldRender()) {
+            return booleanSupplier.getAsBoolean() ? self : empty.get();
+        } else {
+            return self;
+        }
+    }
+
     public abstract String renderCondition(String columnName);
 }

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

@@ -15,7 +15,13 @@
  */
 package org.mybatis.dynamic.sql;
 
-public abstract class AbstractSingleValueCondition<T> implements VisitableCondition<T> {
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+public abstract class AbstractSingleValueCondition<T, S extends AbstractSingleValueCondition<T, S>>
+        implements VisitableCondition<T> {
     protected final T value;
 
     protected AbstractSingleValueCondition(T value) {
@@ -31,5 +37,41 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
+    protected S filter(Predicate<T> predicate, Supplier<S> empty, S self) {
+        if (shouldRender()) {
+            return predicate.test(value) ? self : empty.get();
+        } else {
+            return self;
+        }
+    }
+
+    /**
+     * If renderable and the value matches the predicate, returns this condition. Else returns a condition
+     *     that will not render.
+     *
+     * @param predicate predicate applied to the value, if renderable
+     * @return this condition if renderable and the value matches the predicate, otherwise a condition
+     *     that will not render.
+     */
+    public abstract S filter(Predicate<T> predicate);
+
+    protected S map(UnaryOperator<T> mapper, Function<T, S> constructor, S self) {
+        if (shouldRender()) {
+            return constructor.apply(mapper.apply(value));
+        } else {
+            return self;
+        }
+    }
+
+    /**
+     * 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 abstract S map(UnaryOperator<T> mapper);
+
     public abstract String renderCondition(String columnName, String placeholder);
 }

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

@@ -15,7 +15,13 @@
  */
 package org.mybatis.dynamic.sql;
 
-public abstract class AbstractTwoValueCondition<T> implements VisitableCondition<T> {
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+public abstract class AbstractTwoValueCondition<T, S extends AbstractTwoValueCondition<T, S>>
+        implements VisitableCondition<T> {
     protected final T value1;
     protected final T value2;
 
@@ -37,5 +43,42 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
         return visitor.visit(this);
     }
 
+    protected S filter(BiPredicate<T, 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) {
+        if (shouldRender()) {
+            return constructor.apply(mapper1.apply(value1), mapper2.apply(value2));
+        } else {
+            return self;
+        }
+    }
+
+    /**
+     * 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
+     * @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 abstract S map(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2);
+
     public abstract String renderCondition(String columnName, String placeholder1, String placeholder2);
 }

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

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2016-2020 the original author or authors.
+ *    Copyright 2016-2021 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -20,9 +20,9 @@ public interface ConditionVisitor<T, R> {
 
     R visit(AbstractNoValueCondition<T> condition);
 
-    R visit(AbstractSingleValueCondition<T> condition);
+    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

@@ -21,7 +21,19 @@
 import org.mybatis.dynamic.sql.AbstractTwoValueCondition;
 import org.mybatis.dynamic.sql.util.Predicates;
 
-public class IsBetween<T> extends AbstractTwoValueCondition<T> {
+public class IsBetween<T> extends AbstractTwoValueCondition<T, IsBetween<T>> {
+    private static final IsBetween<?> EMPTY = new IsBetween<Object>(null, null) {
+        @Override
+        public boolean shouldRender() {
+            return false;
+        }
+    };
+
+    public static <T> IsBetween<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsBetween<T> t = (IsBetween<T>) EMPTY;
+        return t;
+    }
 
     protected IsBetween(T value1, T value2) {
         super(value1, value2);
@@ -61,33 +73,14 @@ public IsBetween<T> then(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2) {
         return map(mapper1, mapper2);
     }
 
-    /**
-     * 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.
-     */
+    @Override
     public IsBetween<T> filter(BiPredicate<T, T> predicate) {
-        if (shouldRender()) {
-            return predicate.test(value1, value2) ? this : EmptyIsBetween.empty();
-        } else {
-            return this;
-        }
+        return filter(predicate, IsBetween::empty, 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
-     * @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.
-     */
+    @Override
     public IsBetween<T> map(UnaryOperator<T> mapper1, UnaryOperator<T> mapper2) {
-        return shouldRender() ? new IsBetween<>(mapper1.apply(value1), mapper2.apply(value2)) : this;
+        return map(mapper1, mapper2, IsBetween::new, this);
     }
 
     public static <T> Builder<T> isBetween(T value1) {
@@ -119,23 +112,4 @@ protected IsBetween<T> build() {
             return new IsBetween<>(value1, value2).filter(Predicates.bothPresent());
         }
     }
-
-    public static class EmptyIsBetween<T> extends IsBetween<T> {
-        private static final EmptyIsBetween<?> EMPTY = new EmptyIsBetween<>();
-
-        public static <T> EmptyIsBetween<T> empty() {
-            @SuppressWarnings("unchecked")
-            EmptyIsBetween<T> t = (EmptyIsBetween<T>) EMPTY;
-            return t;
-        }
-
-        private EmptyIsBetween() {
-            super(null, null);
-        }
-
-        @Override
-        public boolean shouldRender() {
-            return false;
-        }
-    }
 }

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

@@ -20,7 +20,20 @@
 
 import org.mybatis.dynamic.sql.AbstractSingleValueCondition;
 
-public class IsEqualTo<T> extends AbstractSingleValueCondition<T> {
+public class IsEqualTo<T> extends AbstractSingleValueCondition<T, IsEqualTo<T>> {
+
+    private static final IsEqualTo<?> EMPTY = new IsEqualTo<Object>(null) {
+        @Override
+        public boolean shouldRender() {
+            return false;
+        }
+    };
+
+    public static <T> IsEqualTo<T> empty() {
+        @SuppressWarnings("unchecked")
+        IsEqualTo<T> t = (IsEqualTo<T>) EMPTY;
+        return t;
+    }
 
     protected IsEqualTo(T value) {
         super(value);
@@ -63,50 +76,13 @@ public IsEqualTo<T> then(UnaryOperator<T> mapper) {
         return map(mapper);
     }
 
-    /**
-     * If renderable and the value matches the predicate, returns this condition. Else returns a condition
-     *     that will not render.
-     *
-     * @param predicate predicate applied to the value, if renderable
-     * @return this condition if renderable and the value matches the predicate, otherwise a condition
-     *     that will not render.
-     */
+    @Override
     public IsEqualTo<T> filter(Predicate<T> predicate) {
-        if (shouldRender()) {
-            return predicate.test(value) ? this : EmptyIsEqualTo.empty();
-        } else {
-            return this;
-        }
+        return filter(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
-     * @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 IsEqualTo<T> map(UnaryOperator<T> mapper) {
-        return shouldRender() ? new IsEqualTo<>(mapper.apply(value)) : this;
-    }
-
-    public static class EmptyIsEqualTo<T> extends IsEqualTo<T> {
-        private static final EmptyIsEqualTo<?> EMPTY = new EmptyIsEqualTo<>();
-
-        public static <T> EmptyIsEqualTo<T> empty() {
-            @SuppressWarnings("unchecked")
-            EmptyIsEqualTo<T> t = (EmptyIsEqualTo<T>) EMPTY;
-            return t;
-        }
-
-        private EmptyIsEqualTo() {
-            super(null);
-        }
-
-        @Override
-        public boolean shouldRender() {
-            return false;
-        }
+        return map(mapper, IsEqualTo::new, this);
     }
 }