org.mybatis.dynamic.sql.AbstractListValueCondition Maven / Gradle / Ivy

Go to download
/*
 *    Copyright ${license.git.copyrightYears} 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.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.mybatis.dynamic.sql;

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.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public abstract class AbstractListValueCondition implements VisitableCondition {
    protected final Collection values;
    protected final Callback emptyCallback;

    protected AbstractListValueCondition(Collection values) {
        this(values, () -> { });
    }

    protected AbstractListValueCondition(Collection values, Callback emptyCallback) {
        this.values = Objects.requireNonNull(values);
        this.emptyCallback = Objects.requireNonNull(emptyCallback);
    }

    public final  Stream mapValues(Function mapper) {
        return values.stream().map(mapper);
    }

    @Override
    public boolean shouldRender() {
        return !values.isEmpty();
    }

    @Override
    public void renderingSkipped() {
        emptyCallback.call();
    }

    @Override
    public  R accept(ConditionVisitor visitor) {
        return visitor.visit(this);
    }

    private  Collection applyMapper(Function mapper) {
        Objects.requireNonNull(mapper);
        return values.stream().map(mapper).collect(Collectors.toList());
    }

    private Collection applyFilter(Predicate predicate) {
        Objects.requireNonNull(predicate);
        return values.stream().filter(predicate).collect(Collectors.toList());
    }

    protected > S filterSupport(Predicate predicate,
            BiFunction, Callback, S> constructor, S self, Supplier emptySupplier) {
        if (shouldRender()) {
            Collection filtered = applyFilter(predicate);
            return filtered.isEmpty() ? emptySupplier.get() : constructor.apply(filtered, emptyCallback);
        } else {
            return self;
        }
    }

    protected > S mapSupport(Function mapper,
            BiFunction, Callback, S> constructor, Supplier emptySupplier) {
        if (shouldRender()) {
            return constructor.apply(applyMapper(mapper), emptyCallback);
        } else {
            return emptySupplier.get();
        }
    }

    /**
     * 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 AbstractListValueCondition filter(Predicate predicate);

    public abstract AbstractListValueCondition withListEmptyCallback(Callback callback);

    public abstract String renderCondition(String columnName, Stream placeholders);
}