Remove Suppliers from the single and two value conditions

This made the conditions inconsistent with the list conditions, and
also inconsistent with the function of the map methods.

Author: jeffgbutler

CHANGELOG.md

@@ -22,6 +22,9 @@ The major themes of this release include the following:
 All built-in conditions have been rafactored. The changes should have no impact for the vast majority of users.
 However, there are some changes in behavior and one breaking change.
 
+1. Internally, the conditions no longer hold value Suppliers, they now hold the values themselves. The SqlBuilder
+   methods that accept Suppliers will call the `Supplier.get()` method when the condition is constructed. This should
+   have no impact unless you were somehow relying on the delay in obtaining a value until the condition was rendered.
 1. The existing "then" and "when" methods have been deprecated and replaced with "map" and "filter" respectively.
    The new method names are more familiar and more representative of what these methods actually do. In effect,
    these methods mimic the function of the "map" and "filter" methods on "java.util.Optional" and they are used
@@ -33,8 +36,8 @@ However, there are some changes in behavior and one breaking change.
    in the SqlBuilder remain, and they will now produce a condition with a "NotNull" filter applied. So at the API level,
    things will function exactly as before, but the intermediate classes will be different.
 1. One breaking change is that the builder for List value conditions has been removed without replacement. If you
-   were using this builder, then the replacement is to build a new List value condition and then call the "map" and
-   "filter" methods as needed. For example, prior code looked like this
+   were using this builder to supply a "value stream transformer", then the replacement is to build a new List value
+   condition and then call the "map" and "filter" methods as needed. For example, prior code looked like this
 
    ```java
     public static IsIn<String> isIn(String...values) {
@@ -46,9 +49,7 @@ However, there are some changes in behavior and one breaking change.
                 .build();
     }
    ```
-   
-    New code should look like this:
-
+   New code should look like this:
    ```java
     public static IsIn<String> isIn(String...values) {
         return SqlBuilder.isIn(values)
@@ -57,7 +58,6 @@ However, there are some changes in behavior and one breaking change.
                 .filter(st -> !st.isEmpty());
     }
    ```
-   
    We think this is a marked improvement!
 
 ### Breaking Change for Kotlin

README.md

@@ -23,11 +23,11 @@ For example, a typical search can be coded with a query like this (the following
         select(Customer.id, Customer.firstName, Customer.lastName) {
             from(Customer)
             where(Customer.active, isEqualTo(true))
-            and(Customer.id, isEqualToWhenPresent(id).then{ it?.padStart(5, '0') })
+            and(Customer.id, isEqualToWhenPresent(id).map{ it?.padStart(5, '0') })
             and(Customer.firstName, isLikeCaseInsensitiveWhenPresent(firstName)
-                .then{ "%" + it.trim() + "%" })
+                .map{ "%" + it.trim() + "%" })
             and(Customer.lastName, isLikeCaseInsensitiveWhenPresent(lastName)
-                .then{ "%" + it.trim() + "%" })
+                .map{ "%" + it.trim() + "%" })
             orderBy(Customer.lastName, Customer.firstName)
             limit(500)
         }

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

@@ -15,18 +15,15 @@
  */
 package org.mybatis.dynamic.sql;
 
-import java.util.Objects;
-import java.util.function.Supplier;
-
 public abstract class AbstractSingleValueCondition<T> implements VisitableCondition<T> {
-    protected final Supplier<T> valueSupplier;
+    protected final T value;
 
-    protected AbstractSingleValueCondition(Supplier<T> valueSupplier) {
-        this.valueSupplier = Objects.requireNonNull(valueSupplier);
+    protected AbstractSingleValueCondition(T value) {
+        this.value = value;
     }
 
     public T value() {
-        return valueSupplier.get();
+        return value;
     }
 
     @Override

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

@@ -15,24 +15,21 @@
  */
 package org.mybatis.dynamic.sql;
 
-import java.util.Objects;
-import java.util.function.Supplier;
-
 public abstract class AbstractTwoValueCondition<T> implements VisitableCondition<T> {
-    protected final Supplier<T> valueSupplier1;
-    protected final Supplier<T> valueSupplier2;
+    protected final T value1;
+    protected final T value2;
 
-    protected AbstractTwoValueCondition(Supplier<T> valueSupplier1, Supplier<T> valueSupplier2) {
-        this.valueSupplier1 = Objects.requireNonNull(valueSupplier1);
-        this.valueSupplier2 = Objects.requireNonNull(valueSupplier2);
+    protected AbstractTwoValueCondition(T value1, T value2) {
+        this.value1 = value1;
+        this.value2 = value2;
     }
 
     public T value1() {
-        return valueSupplier1.get();
+        return value1;
     }
 
     public T value2() {
-        return valueSupplier2.get();
+        return value2;
     }
 
     @Override

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

@@ -414,11 +414,11 @@ static <T> IsNotNull<T> isNotNull() {
     }
 
     static <T> IsEqualTo<T> isEqualTo(T value) {
-        return isEqualTo(() -> value);
+        return IsEqualTo.of(value);
     }
 
     static <T> IsEqualTo<T> isEqualTo(Supplier<T> valueSupplier) {
-        return IsEqualTo.of(valueSupplier);
+        return isEqualTo(valueSupplier.get());
     }
 
     static <T> IsEqualToWithSubselect<T> isEqualTo(Buildable<SelectModel> selectModelBuilder) {
@@ -430,19 +430,19 @@ static <T> IsEqualToColumn<T> isEqualTo(BasicColumn column) {
     }
 
     static <T> IsEqualTo<T> isEqualToWhenPresent(T value) {
-        return isEqualToWhenPresent(() -> value);
+        return IsEqualTo.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsEqualTo<T> isEqualToWhenPresent(Supplier<T> valueSupplier) {
-        return IsEqualTo.of(valueSupplier).filter(Objects::nonNull);
+        return isEqualToWhenPresent(valueSupplier.get());
     }
 
     static <T> IsNotEqualTo<T> isNotEqualTo(T value) {
-        return isNotEqualTo(() -> value);
+        return IsNotEqualTo.of(value);
     }
 
     static <T> IsNotEqualTo<T> isNotEqualTo(Supplier<T> valueSupplier) {
-        return IsNotEqualTo.of(valueSupplier);
+        return isNotEqualTo(valueSupplier.get());
     }
 
     static <T> IsNotEqualToWithSubselect<T> isNotEqualTo(Buildable<SelectModel> selectModelBuilder) {
@@ -454,19 +454,19 @@ static <T> IsNotEqualToColumn<T> isNotEqualTo(BasicColumn column) {
     }
 
     static <T> IsNotEqualTo<T> isNotEqualToWhenPresent(T value) {
-        return isNotEqualToWhenPresent(() -> value);
+        return IsNotEqualTo.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsNotEqualTo<T> isNotEqualToWhenPresent(Supplier<T> valueSupplier) {
-        return IsNotEqualTo.of(valueSupplier).filter(Objects::nonNull);
+        return isNotEqualToWhenPresent(valueSupplier.get());
     }
 
     static <T> IsGreaterThan<T> isGreaterThan(T value) {
-        return isGreaterThan(() -> value);
+        return IsGreaterThan.of(value);
     }
 
     static <T> IsGreaterThan<T> isGreaterThan(Supplier<T> valueSupplier) {
-        return IsGreaterThan.of(valueSupplier);
+        return isGreaterThan(valueSupplier.get());
     }
 
     static <T> IsGreaterThanWithSubselect<T> isGreaterThan(Buildable<SelectModel> selectModelBuilder) {
@@ -478,19 +478,19 @@ static <T> IsGreaterThanColumn<T> isGreaterThan(BasicColumn column) {
     }
 
     static <T> IsGreaterThan<T> isGreaterThanWhenPresent(T value) {
-        return isGreaterThanWhenPresent(() -> value);
+        return IsGreaterThan.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsGreaterThan<T> isGreaterThanWhenPresent(Supplier<T> valueSupplier) {
-        return IsGreaterThan.of(valueSupplier).filter(Objects::nonNull);
+        return isGreaterThanWhenPresent(valueSupplier.get());
     }
 
     static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T value) {
-        return isGreaterThanOrEqualTo(() -> value);
+        return IsGreaterThanOrEqualTo.of(value);
     }
 
     static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(Supplier<T> valueSupplier) {
-        return IsGreaterThanOrEqualTo.of(valueSupplier);
+        return isGreaterThanOrEqualTo(valueSupplier.get());
     }
 
     static <T> IsGreaterThanOrEqualToWithSubselect<T> isGreaterThanOrEqualTo(
@@ -503,19 +503,19 @@ static <T> IsGreaterThanOrEqualToColumn<T> isGreaterThanOrEqualTo(BasicColumn co
     }
 
     static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualToWhenPresent(T value) {
-        return isGreaterThanOrEqualToWhenPresent(() -> value);
+        return IsGreaterThanOrEqualTo.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualToWhenPresent(Supplier<T> valueSupplier) {
-        return IsGreaterThanOrEqualTo.of(valueSupplier).filter(Objects::nonNull);
+        return isGreaterThanOrEqualToWhenPresent(valueSupplier.get());
     }
 
     static <T> IsLessThan<T> isLessThan(T value) {
-        return isLessThan(() -> value);
+        return IsLessThan.of(value);
     }
 
     static <T> IsLessThan<T> isLessThan(Supplier<T> valueSupplier) {
-        return IsLessThan.of(valueSupplier);
+        return isLessThan(valueSupplier.get());
     }
 
     static <T> IsLessThanWithSubselect<T> isLessThan(Buildable<SelectModel> selectModelBuilder) {
@@ -527,19 +527,19 @@ static <T> IsLessThanColumn<T> isLessThan(BasicColumn column) {
     }
 
     static <T> IsLessThan<T> isLessThanWhenPresent(T value) {
-        return isLessThanWhenPresent(() -> value);
+        return IsLessThan.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsLessThan<T> isLessThanWhenPresent(Supplier<T> valueSupplier) {
-        return IsLessThan.of(valueSupplier).filter(Objects::nonNull);
+        return isLessThanWhenPresent(valueSupplier.get());
     }
 
     static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(T value) {
-        return isLessThanOrEqualTo(() -> value);
+        return IsLessThanOrEqualTo.of(value);
     }
 
     static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(Supplier<T> valueSupplier) {
-        return IsLessThanOrEqualTo.of(valueSupplier);
+        return isLessThanOrEqualTo(valueSupplier.get());
     }
 
     static <T> IsLessThanOrEqualToWithSubselect<T> isLessThanOrEqualTo(Buildable<SelectModel> selectModelBuilder) {
@@ -551,11 +551,11 @@ static <T> IsLessThanOrEqualToColumn<T> isLessThanOrEqualTo(BasicColumn column)
     }
 
     static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualToWhenPresent(T value) {
-        return isLessThanOrEqualToWhenPresent(() -> value);
+        return IsLessThanOrEqualTo.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualToWhenPresent(Supplier<T> valueSupplier) {
-        return IsLessThanOrEqualTo.of(valueSupplier).filter(Objects::nonNull);
+        return isLessThanOrEqualToWhenPresent(valueSupplier.get());
     }
 
     @SafeVarargs
@@ -603,68 +603,68 @@ static <T> IsNotIn<T> isNotInWhenPresent(Collection<T> values) {
     }
 
     static <T> IsBetween.Builder<T> isBetween(T value1) {
-        return isBetween(() -> value1);
+        return IsBetween.isBetween(value1);
     }
 
     static <T> IsBetween.Builder<T> isBetween(Supplier<T> valueSupplier1) {
-        return IsBetween.isBetween(valueSupplier1);
+        return isBetween(valueSupplier1.get());
     }
 
     static <T> IsBetween.WhenPresentBuilder<T> isBetweenWhenPresent(T value1) {
-        return isBetweenWhenPresent(() -> value1);
+        return IsBetween.isBetweenWhenPresent(value1);
     }
 
     static <T> IsBetween.WhenPresentBuilder<T> isBetweenWhenPresent(Supplier<T> valueSupplier1) {
-        return IsBetween.isBetweenWhenPresent(valueSupplier1);
+        return isBetweenWhenPresent(valueSupplier1.get());
     }
 
     static <T> IsNotBetween.Builder<T> isNotBetween(T value1) {
-        return isNotBetween(() -> value1);
+        return IsNotBetween.isNotBetween(value1);
     }
 
     static <T> IsNotBetween.Builder<T> isNotBetween(Supplier<T> valueSupplier1) {
-        return IsNotBetween.isNotBetween(valueSupplier1);
+        return isNotBetween(valueSupplier1.get());
     }
 
     static <T> IsNotBetween.WhenPresentBuilder<T> isNotBetweenWhenPresent(T value1) {
-        return isNotBetweenWhenPresent(() -> value1);
+        return IsNotBetween.isNotBetweenWhenPresent(value1);
     }
 
     static <T> IsNotBetween.WhenPresentBuilder<T> isNotBetweenWhenPresent(Supplier<T> valueSupplier1) {
-        return IsNotBetween.isNotBetweenWhenPresent(valueSupplier1);
+        return isNotBetweenWhenPresent(valueSupplier1.get());
     }
 
     // for string columns, but generic for columns with type handlers
     static <T> IsLike<T> isLike(T value) {
-        return isLike(() -> value);
+        return IsLike.of(value);
     }
 
     static <T> IsLike<T> isLike(Supplier<T> valueSupplier) {
-        return IsLike.of(valueSupplier);
+        return isLike(valueSupplier.get());
     }
 
     static <T> IsLike<T> isLikeWhenPresent(T value) {
-        return isLikeWhenPresent(() -> value);
+        return IsLike.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsLike<T> isLikeWhenPresent(Supplier<T> valueSupplier) {
-        return IsLike.of(valueSupplier).filter(Objects::nonNull);
+        return isLikeWhenPresent(valueSupplier.get());
     }
 
     static <T> IsNotLike<T> isNotLike(T value) {
-        return isNotLike(() -> value);
+        return IsNotLike.of(value);
     }
 
     static <T> IsNotLike<T> isNotLike(Supplier<T> valueSupplier) {
-        return IsNotLike.of(valueSupplier);
+        return isNotLike(valueSupplier.get());
     }
 
     static <T> IsNotLike<T> isNotLikeWhenPresent(T value) {
-        return isNotLikeWhenPresent(() -> value);
+        return IsNotLike.of(value).filter(Objects::nonNull);
     }
 
     static <T> IsNotLike<T> isNotLikeWhenPresent(Supplier<T> valueSupplier) {
-        return IsNotLike.of(valueSupplier).filter(Objects::nonNull);
+        return isNotLikeWhenPresent(valueSupplier.get());
     }
 
     // shortcuts for booleans
@@ -678,35 +678,35 @@ static IsEqualTo<Boolean> isFalse() {
 
     // conditions for strings only
     static IsLikeCaseInsensitive isLikeCaseInsensitive(String value) {
-        return isLikeCaseInsensitive(() -> value);
+        return IsLikeCaseInsensitive.of(value);
     }
 
     static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<String> valueSupplier) {
-        return IsLikeCaseInsensitive.of(valueSupplier);
+        return isLikeCaseInsensitive(valueSupplier.get());
     }
 
     static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(String value) {
-        return isLikeCaseInsensitiveWhenPresent(() -> value);
+        return IsLikeCaseInsensitive.of(value).filter(Objects::nonNull);
     }
 
     static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier) {
-        return IsLikeCaseInsensitive.of(valueSupplier).filter(Objects::nonNull);
+        return isLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 
     static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value) {
-        return isNotLikeCaseInsensitive(() -> value);
+        return IsNotLikeCaseInsensitive.of(value);
     }
 
     static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {
-        return IsNotLikeCaseInsensitive.of(valueSupplier);
+        return isNotLikeCaseInsensitive(valueSupplier.get());
     }
 
     static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(String value) {
-        return isNotLikeCaseInsensitiveWhenPresent(() -> value);
+        return IsNotLikeCaseInsensitive.of(value).filter(Objects::nonNull);
     }
 
     static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier) {
-        return IsNotLikeCaseInsensitive.of(valueSupplier).filter(Objects::nonNull);
+        return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());
     }
 
     static IsInCaseInsensitive isInCaseInsensitive(String...values) {