More code optimizations

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereDSL.java

@@ -19,6 +19,7 @@
 import java.util.Arrays;
 import java.util.List;
 
+import org.jetbrains.annotations.NotNull;
 import org.mybatis.dynamic.sql.BindableColumn;
 import org.mybatis.dynamic.sql.SqlCriterion;
 import org.mybatis.dynamic.sql.VisitableCondition;
@@ -30,51 +31,61 @@ protected AbstractWhereDSL() {
         super();
     }
 
+    @NotNull
     public <S> T where(BindableColumn<S> column, VisitableCondition<S> condition) {
         addCriterion(column, condition);
         return getThis();
     }
 
+    @NotNull
     public <S> T where(BindableColumn<S> column, VisitableCondition<S> condition, SqlCriterion<?>...subCriteria) {
         addCriterion(column, condition, Arrays.asList(subCriteria));
         return getThis();
     }
 
+    @NotNull
     public <S> T where(BindableColumn<S> column, VisitableCondition<S> condition, List<SqlCriterion<?>> subCriteria) {
         addCriterion(column, condition, subCriteria);
         return getThis();
     }
 
+    @NotNull
     public T applyWhere(WhereApplier whereApplier) {
         whereApplier.accept(this);
         return getThis();
     }
 
+    @NotNull
     public <S> T and(BindableColumn<S> column, VisitableCondition<S> condition) {
         addCriterion("and", column, condition); //$NON-NLS-1$
         return getThis();
     }
 
+    @NotNull
     public <S> T and(BindableColumn<S> column, VisitableCondition<S> condition, SqlCriterion<?>...subCriteria) {
         addCriterion("and", column, condition, Arrays.asList(subCriteria)); //$NON-NLS-1$
         return getThis();
     }
 
+    @NotNull
     public <S> T and(BindableColumn<S> column, VisitableCondition<S> condition, List<SqlCriterion<?>> subCriteria) {
         addCriterion("and", column, condition, subCriteria); //$NON-NLS-1$
         return getThis();
     }
 
+    @NotNull
     public <S> T or(BindableColumn<S> column, VisitableCondition<S> condition) {
         addCriterion("or", column, condition); //$NON-NLS-1$
         return getThis();
     }
 
+    @NotNull
     public <S> T or(BindableColumn<S> column, VisitableCondition<S> condition, SqlCriterion<?>...subCriteria) {
         addCriterion("or", column, condition, Arrays.asList(subCriteria)); //$NON-NLS-1$
         return getThis();
     }
 
+    @NotNull
     public <S> T or(BindableColumn<S> column, VisitableCondition<S> condition, List<SqlCriterion<?>> subCriteria) {
         addCriterion("or", column, condition, subCriteria); //$NON-NLS-1$
         return getThis();

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/AbstractQueryExpressionDSLExtensions.kt

@@ -21,56 +21,48 @@ import org.mybatis.dynamic.sql.select.SelectModel
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .join(table: SqlTable, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return join(table, collector.onJoinCriterion, collector.andJoinCriteria)
 }
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .join(table: SqlTable, alias: String, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return join(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
 }
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .fullJoin(table: SqlTable, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return fullJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
 }
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .fullJoin(table: SqlTable, alias: String, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return fullJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
 }
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .leftJoin(table: SqlTable, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return leftJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
 }
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .leftJoin(table: SqlTable, alias: String, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return leftJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
 }
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .rightJoin(table: SqlTable, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return rightJoin(table, collector.onJoinCriterion, collector.andJoinCriteria)
 }
 
 fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<T, SelectModel>
         .rightJoin(table: SqlTable, alias: String, collect: JoinReceiver): T {
-    val collector = JoinCollector()
-    collect(collector)
+    val collector = collect(JoinCollector())
     return rightJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
 }

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/AbstractWhereDSLExtensions.kt

@@ -21,20 +21,21 @@ import org.mybatis.dynamic.sql.where.AbstractWhereDSL
 
 typealias WhereApplier = AbstractWhereDSL<*>.() -> Unit
 
-fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): M {
-    val collector = CriteriaCollector()
-    collect(collector)
-    return where(column, condition, collector.criteria)
-}
+fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.where(
+    column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver
+) =
+    where(column, condition, collect(CriteriaCollector()).criteria)
 
-fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): M {
-    val collector = CriteriaCollector()
-    collect(collector)
-    return and(column, condition, collector.criteria)
-}
+fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.and(
+    column: BindableColumn<T>,
+    condition: VisitableCondition<T>,
+    collect: CriteriaReceiver
+) =
+    and(column, condition, collect(CriteriaCollector()).criteria)
 
-fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): M {
-    val collector = CriteriaCollector()
-    collect(collector)
-    return or(column, condition, collector.criteria)
-}
+fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.or(
+    column: BindableColumn<T>,
+    condition: VisitableCondition<T>,
+    collect: CriteriaReceiver
+) =
+    or(column, condition, collect(CriteriaCollector()).criteria)