Merge pull request #264 from jeffgbutler/master

Refactoring towards full immutability

Author: jeffgbutler

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

@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Objects;
 import java.util.function.Function;
@@ -28,20 +29,11 @@ public abstract class AbstractListValueCondition<T, S extends AbstractListValueC
     protected final UnaryOperator<Stream<T>> valueStreamTransformer;
     protected final Callback emptyCallback;
 
-    protected AbstractListValueCondition(Collection<T> values) {
-        this(values, UnaryOperator.identity(), () -> { });
-    }
-
-    protected AbstractListValueCondition(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer) {
-        this(values, valueStreamTransformer, () -> { });
-    }
-
-    protected AbstractListValueCondition(Collection<T> values, UnaryOperator<Stream<T>> valueStreamTransformer,
-            Callback emptyCallback) {
-        this.valueStreamTransformer = Objects.requireNonNull(valueStreamTransformer);
-        this.values = valueStreamTransformer.apply(Objects.requireNonNull(values).stream())
+    protected AbstractListValueCondition(AbstractListConditionBuilder<T, ?> builder) {
+        this.valueStreamTransformer = Objects.requireNonNull(builder.valueStreamTransformer);
+        this.values = valueStreamTransformer.apply(builder.values.stream())
             .collect(Collectors.toList());
-        this.emptyCallback = Objects.requireNonNull(emptyCallback);
+        this.emptyCallback = Objects.requireNonNull(builder.emptyCallback);
     }
 
     public final <R> Stream<R> mapValues(Function<T, R> mapper) {
@@ -66,4 +58,27 @@ public <R> R accept(ConditionVisitor<T, R> visitor) {
     public abstract S withListEmptyCallback(Callback callback);
 
     public abstract String renderCondition(String columnName, Stream<String> placeholders);
+
+    public abstract static class AbstractListConditionBuilder<T, S extends AbstractListConditionBuilder<T,S>> {
+        protected Collection<T> values = new ArrayList<>();
+        protected UnaryOperator<Stream<T>> valueStreamTransformer = UnaryOperator.identity();
+        protected Callback emptyCallback = () -> { };
+
+        public S withValues(Collection<T> values) {
+            this.values.addAll(values);
+            return getThis();
+        }
+
+        public S withValueStreamTransformer(UnaryOperator<Stream<T>> valueStreamTransformer) {
+            this.valueStreamTransformer = valueStreamTransformer;
+            return getThis();
+        }
+
+        public S withEmptyCallback(Callback emptyCallback) {
+            this.emptyCallback = emptyCallback;
+            return getThis();
+        }
+
+        protected abstract S getThis();
+    }
 }

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

@@ -22,11 +22,16 @@
 
 public class Constant<T> implements BindableColumn<T> {
 
-    private String alias;
+    private final String alias;
     private final String value;
 
     private Constant(String value) {
+        this(value, null);
+    }
+
+    private Constant(String value, String alias) {
         this.value = Objects.requireNonNull(value);
+        this.alias = alias;
     }
 
     @Override
@@ -41,9 +46,7 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
 
     @Override
     public Constant<T> as(String alias) {
-        Constant<T> copy = new Constant<>(value);
-        copy.alias = alias;
-        return copy;
+        return new Constant<>(value, alias);
     }
 
     public static <T> Constant<T> of(String value) {

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

@@ -28,28 +28,21 @@ public class SqlColumn<T> implements BindableColumn<T>, SortSpecification {
     protected final String name;
     protected final SqlTable table;
     protected final JDBCType jdbcType;
-    protected boolean isDescending = false;
-    protected String alias;
-    protected String typeHandler;
-    protected RenderingStrategy renderingStrategy;
-    protected ParameterTypeConverter<T, ?> parameterTypeConverter;
+    protected final boolean isDescending;
+    protected final String alias;
+    protected final String typeHandler;
+    protected final RenderingStrategy renderingStrategy;
+    protected final ParameterTypeConverter<T, ?> parameterTypeConverter;
 
-    private SqlColumn(Builder builder) {
+    private SqlColumn(Builder<T> builder) {
         name = Objects.requireNonNull(builder.name);
-        jdbcType = builder.jdbcType;
         table = Objects.requireNonNull(builder.table);
+        jdbcType = builder.jdbcType;
+        isDescending = builder.isDescending;
+        alias = builder.alias;
         typeHandler = builder.typeHandler;
-    }
-
-    protected SqlColumn(SqlColumn<T> sqlColumn) {
-        name = sqlColumn.name;
-        table = sqlColumn.table;
-        jdbcType = sqlColumn.jdbcType;
-        isDescending = sqlColumn.isDescending;
-        alias = sqlColumn.alias;
-        typeHandler = sqlColumn.typeHandler;
-        renderingStrategy = sqlColumn.renderingStrategy;
-        parameterTypeConverter = sqlColumn.parameterTypeConverter;
+        renderingStrategy = builder.renderingStrategy;
+        parameterTypeConverter = builder.parameterTypeConverter;
     }
 
     public String name() {
@@ -82,16 +75,14 @@ public Object convertParameterType(T value) {
 
     @Override
     public SortSpecification descending() {
-        SqlColumn<T> column = new SqlColumn<>(this);
-        column.isDescending = true;
-        return column;
+        Builder<T> b = copy();
+        return b.withDescending(true).build();
     }
 
     @Override
     public SqlColumn<T> as(String alias) {
-        SqlColumn<T> column = new SqlColumn<>(this);
-        column.alias = alias;
-        return column;
+        Builder<T> b = copy();
+        return b.withAlias(alias).build();
     }
 
     @Override
@@ -118,23 +109,20 @@ public Optional<RenderingStrategy> renderingStrategy() {
 
     @NotNull
     public <S> SqlColumn<S> withTypeHandler(String typeHandler) {
-        SqlColumn<S> column = copy();
-        column.typeHandler = typeHandler;
-        return column;
+        Builder<S> b = copy();
+        return b.withTypeHandler(typeHandler).build();
     }
 
     @NotNull
     public <S> SqlColumn<S> withRenderingStrategy(RenderingStrategy renderingStrategy) {
-        SqlColumn<S> column = copy();
-        column.renderingStrategy = renderingStrategy;
-        return column;
+        Builder<S> b = copy();
+        return b.withRenderingStrategy(renderingStrategy).build();
     }
 
     @NotNull
     public <S> SqlColumn<S> withParameterTypeConverter(ParameterTypeConverter<S, ?> parameterTypeConverter) {
-        SqlColumn<S> column = copy();
-        column.parameterTypeConverter = parameterTypeConverter;
-        return column;
+        Builder<S> b = copy();
+        return b.withParameterTypeConverter(parameterTypeConverter).build();
     }
 
     /**
@@ -147,58 +135,86 @@ public <S> SqlColumn<S> withParameterTypeConverter(ParameterTypeConverter<S, ?>
      * @return a new SqlColumn of type S (S is the same as T)
      */
     @SuppressWarnings("unchecked")
-    private <S> SqlColumn<S> copy() {
-        return new SqlColumn<>((SqlColumn<S>) this);
+    private <S> Builder<S> copy() {
+        return new Builder<S>()
+                .withName(this.name)
+                .withTable(this.table)
+                .withJdbcType(this.jdbcType)
+                .withDescending(this.isDescending)
+                .withAlias(this.alias)
+                .withTypeHandler(this.typeHandler)
+                .withRenderingStrategy((this.renderingStrategy))
+                .withParameterTypeConverter((ParameterTypeConverter<S, ?>) this.parameterTypeConverter);
     }
 
     private String applyTableAlias(String tableAlias) {
         return tableAlias + "." + name(); //$NON-NLS-1$
     }
 
     public static <T> SqlColumn<T> of(String name, SqlTable table) {
-        return SqlColumn.withName(name)
+        return new Builder<T>().withName(name)
                 .withTable(table)
                 .build();
     }
 
     public static <T> SqlColumn<T> of(String name, SqlTable table, JDBCType jdbcType) {
-        return SqlColumn.withName(name)
+        return new Builder<T>().withName(name)
                 .withTable(table)
                 .withJdbcType(jdbcType)
                 .build();
     }
 
-    public static Builder withName(String name) {
-        return new Builder().withName(name);
-    }
+    public static class Builder<T> {
+        protected String name;
+        protected SqlTable table;
+        protected JDBCType jdbcType;
+        protected boolean isDescending = false;
+        protected String alias;
+        protected String typeHandler;
+        protected RenderingStrategy renderingStrategy;
+        protected ParameterTypeConverter<T, ?> parameterTypeConverter;
 
-    public static class Builder {
-        private SqlTable table;
-        private String name;
-        private JDBCType jdbcType;
-        private String typeHandler;
+        public Builder<T> withName(String name) {
+            this.name = name;
+            return this;
+        }
 
-        public Builder withTable(SqlTable table) {
+        public Builder<T> withTable(SqlTable table) {
             this.table = table;
             return this;
         }
 
-        public Builder withName(String name) {
-            this.name = name;
+        public Builder<T> withJdbcType(JDBCType jdbcType) {
+            this.jdbcType = jdbcType;
             return this;
         }
 
-        public Builder withJdbcType(JDBCType jdbcType) {
-            this.jdbcType = jdbcType;
+        public Builder<T> withDescending(boolean isDescending) {
+            this.isDescending = isDescending;
             return this;
         }
 
-        public Builder withTypeHandler(String typeHandler) {
+        public Builder<T> withAlias(String alias) {
+            this.alias = alias;
+            return this;
+        }
+
+        public Builder<T> withTypeHandler(String typeHandler) {
             this.typeHandler = typeHandler;
             return this;
         }
 
-        public <T> SqlColumn<T> build() {
+        public Builder<T> withRenderingStrategy(RenderingStrategy renderingStrategy) {
+            this.renderingStrategy = renderingStrategy;
+            return this;
+        }
+
+        public Builder<T> withParameterTypeConverter(ParameterTypeConverter<T, ?> parameterTypeConverter) {
+            this.parameterTypeConverter = parameterTypeConverter;
+            return this;
+        }
+
+        public SqlColumn<T> build() {
             return new SqlColumn<>(this);
         }
     }

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

@@ -22,11 +22,16 @@
 
 public class StringConstant implements BindableColumn<String> {
 
-    private String alias;
+    private final String alias;
     private final String value;
 
     private StringConstant(String value) {
+        this(value, null);
+    }
+
+    private StringConstant(String value, String alias) {
         this.value = Objects.requireNonNull(value);
+        this.alias = alias;
     }
 
     @Override
@@ -41,9 +46,7 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
 
     @Override
     public StringConstant as(String alias) {
-        StringConstant copy = new StringConstant(value);
-        copy.alias = alias;
-        return copy;
+        return new StringConstant(value, alias);
     }
 
     public static StringConstant of(String value) {

src/main/java/org/mybatis/dynamic/sql/select/SimpleSortSpecification.java

@@ -28,17 +28,21 @@
 public class SimpleSortSpecification implements SortSpecification {
 
     private final String name;
-    private boolean isDescending;
+    private final boolean isDescending;
 
     private SimpleSortSpecification(String name) {
         this.name = Objects.requireNonNull(name);
+        this.isDescending = false;
+    }
+
+    private SimpleSortSpecification(String name, boolean isDescending) {
+        this.name = Objects.requireNonNull(name);
+        this.isDescending = isDescending;
     }
 
     @Override
     public SortSpecification descending() {
-        SimpleSortSpecification answer = new SimpleSortSpecification(name);
-        answer.isDescending = true;
-        return answer;
+        return new SimpleSortSpecification(name, true);
     }
 
     @Override