拒绝各种ifelse的神器来了

拒绝各种ifelse的神器来了。持续完善中……

package com.hcjy.common.util.check;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * if工具类
 * @author fay
 * @date 2022-08-29
 */
public class Ifs<T> {

    private final T value;

    private Ifs(T value) {
        this.value = value;
    }

    /**
     * 实例化
     * @param value 需要判断的对象
     */
    public static <T> Ifs<T> of(T value) {
        return new Ifs<>(value);
    }

    /**
     * value满足条件执行consumer消费value
     * @param predicate 条件
     * @param consumer 消费者
     */
    public void apply(Predicate<? super T> predicate, Consumer<? super T> consumer) {
        if (predicate.test(value)) {
            consumer.accept(value);
        }
    }

    /**
     * value满足条件执行consumer消费value，否则执行consumer1消费b
     * @param predicate 条件
     * @param consumer 消费者1
     * @param b 入参对象
     * @param consumer1 消费者2
     */
    public <R> void apply(Predicate<? super T> predicate, Consumer<? super T> consumer, R b, Consumer<? super R> consumer1) {
        if (predicate.test(value)) {
            consumer.accept(value);
        } else {
            consumer1.accept(b);
        }
    }

    /**
     * value满足条件返回value，否则返回b
     * @param predicate 条件
     * @param b 入参对象
     * @return value/b
     */
    public T or(Predicate<? super T> predicate, T b) {
        return predicate.test(value) ? b : value;
    }

    /**
     * value满足条件返回a，否则返回b
     * @param predicate 条件
     * @param a 入参对象
     * @param b 入参对象
     * @return a/b
     */
    public <R> R or(Predicate<? super T> predicate, R a, R b) {
        return predicate.test(value) ? a : b;
    }

    /**
     * value满足条件执行function处理value返回value类型，否则返回value
     * @param predicate 条件
     * @param function 执行者
     * @return true -> 入参对象执行返回值, false -> 当前值
     */
    public T or(Predicate<? super T> predicate, Function<? super T, ? extends T> function) {
        return predicate.test(value) ? function.apply(value) : value;
    }

    /**
     * value满足条件执行function处理value返回b类型，否则返回value
     * @param predicate 条件
     * @param b 入参对象
     * @param function 执行者
     * @return 满足条件返回入参对象执行返回值，否则返回当前值
     */
    public <R> T or(Predicate<? super T> predicate, R b, Function<? super R, ? extends T> function) {
        return predicate.test(value) ? function.apply(b) : value;
    }

    /**
     * value满足条件执行function处理value返回b类型，否则返回b
     * @param predicate 条件
     * @param function 执行者
     * @return true -> 入参对象执行返回值, false -> 当前值
     */
    public <R> R or(Predicate<? super T> predicate, Function<? super T, ? extends R> function, R b) {
        return predicate.test(value) ? function.apply(value) : b;
    }

    /**
     * value满足条件执行function处理value否则执行function1处理value，返回b类型
     * @param predicate 条件
     * @param function 执行者
     * @param function1 执行者1
     * @return true -> 入参对象执行返回值, false -> 当前值
     */
    public <R> R or(Predicate<? super T> predicate, Function<? super T, ? extends R> function, Function<? super T, ? extends R> function1) {
        return predicate.test(value) ? function.apply(value) : function1.apply(value);
    }

    /**
     * value满足条件执行function处理value否则执行function1处理b，返回c类型
     * @param predicate 条件
     * @param function 执行者
     * @param function1 执行者1
     * @return true -> 入参对象执行返回值, false -> 当前值
     */
    public <R, V> V or(Predicate<? super T> predicate, Function<? super T, ? extends V> function, R b, Function<? super R, ? extends V> function1) {
        return predicate.test(value) ? function.apply(value) : function1.apply(b);
    }

    /**
     * value满足条件执行function处理b否则执行function1处理b，返回c类型
     * @param predicate 条件
     * @param function 执行者
     * @param function1 执行者1
     * @return true -> 入参对象执行返回值, false -> 当前值
     */
    public <R, V> V or(Predicate<? super T> predicate, R b, Function<? super R, ? extends V> function, Function<? super R, ? extends V> function1) {
        return predicate.test(value) ? function.apply(b) : function1.apply(b);
    }

    /**
     * value满足条件执行function处理a否则执行function1处理b，返回c类型
     * @param predicate 条件
     * @param function 执行者
     * @param function1 执行者1
     * @return true -> 入参对象执行返回值, false -> 当前值
     */
    public <R, O, V> V or(Predicate<? super T> predicate, R a, Function<? super R, ? extends V> function, O b, Function<? super O, ? extends V> function1) {
        return predicate.test(value) ? function.apply(a) : function1.apply(b);
    }

    /**
     * value满足条件执行supplier生产value类型，否则返回value
     * @param predicate 条件
     * @param supplier 提供者
     * @return true -> 提供返回值, false -> 当前值
     */
    public T or(Predicate<? super T> predicate, Supplier<? extends T> supplier) {
        return predicate.test(value) ? supplier.get() : value;
    }

    /**
     * 满足条件消费value
     * @param condition true / false
     * @param consumer 消费者
     */
    public void apply(boolean condition, Consumer<? super T> consumer) {
        if (condition) {
            consumer.accept(value);
        }
    }

    /**
     * 满足条件执行consumer消费value，否则执行consumer1消费b
     * @param condition true / false
     * @param consumer 消费者
     * @param b 其他对象
     * @param consumer1 消费者1
     */
    public <R> void apply(boolean condition, Consumer<? super T> consumer, R b, Consumer<? super R> consumer1) {
        if (condition) {
            consumer.accept(value);
        } else {
            consumer1.accept(b);
        }
    }

    /**
     * 满足条件返回value，否则返回b
     * @param condition true / false
     * @param b 入参对象
     * @return true -> value, false -> b
     */
    public T or(boolean condition, T b) {
        return condition ? value : b;
    }

    /**
     * 满足条件执行function处理value返回value类型，否则返回value
     * @param condition true / false
     * @param function 执行者
     * @return true -> 执行返回值, false -> 当前值
     */
    public T or(boolean condition, Function<? super T, ? extends T> function) {
        return condition ? function.apply(value) : value;
    }

    /**
     * 满足条件执行function处理value否则执行function1处理value，返回b类型
     * @param condition true / false
     * @param function 执行者
     * @return true -> 执行返回值, false -> 当前值
     */
    public <R> R or(boolean condition, Function<? super T, ? extends R> function, Function<? super T, ? extends R> function1) {
        return condition ? function.apply(value) : function1.apply(value);
    }

    /**
     * 满足条件执行function处理value否则执行function1处理b，返回c类型
     * @param condition true / false
     * @param function 执行者
     * @return true -> 执行返回值, false -> 当前值
     */
    public <R, V> V or(boolean condition, Function<? super R, ? extends V> function, R b, Function<? super R, ? extends V> function1) {
        return condition ? function.apply(b) : function1.apply(b);
    }

    /**
     * 满足条件执行supplier1生产value类型，否则返回value
     * @param condition true / false
     * @param supplier 提供者
     * @return true -> 提供返回值, false -> 当前值
     */
    public T or(boolean condition, Supplier<? extends T> supplier) {
        return condition ? supplier.get() : value;
    }

    /**
     * 满足条件消费a
     * @param condition true / false
     * @param a 其他对象
     * @param consumer 消费者
     */
    public static <R> void apply(boolean condition, R a, Consumer<? super R> consumer) {
        if (condition) {
            consumer.accept(a);
        }
    }

    /**
     * 满足条件消费a，否则消费b
     * @param condition true / false
     * @param a 对象a
     * @param consumer 消费者1
     * @param b 对象b
     * @param consumer1 消费者2
     */
    public static <R, V> void apply(boolean condition, R a, Consumer<? super R> consumer, V b, Consumer<? super V> consumer1) {
        if (condition) {
            consumer.accept(a);
        } else {
            consumer1.accept(b);
        }
    }

    /**
     * 满足条件消费a，否则消费b
     * @param condition true / false
     * @param a 消费者1
     * @param b 其他对象
     * @return true -> a, false -> b
     */
    public static <R> R or(boolean condition, R a, R b) {
        return condition ? a : b;
    }

    /**
     * 满足条件执行function处理b否则执行function1处理b，返回c类型
     * @param condition true / false
     * @param function 执行者
     * @param function1 执行者1
     * @return true -> 执行function处理b返回c类型, false -> 执行function1处理b返回c类型
     */
    public static <R, V> V or(boolean condition, R b, Function<? super R, ? extends V> function, Function<? super R, ? extends V> function1) {
        return condition ? function.apply(b) : function1.apply(b);
    }

    /**
     * 满足条件执行function处理a否则执行function1处理b，返回c类型
     * @param condition true / false
     * @param function 执行者
     * @param function1 执行者1
     * @return true -> 执行function处理b返回c类型, false -> 执行function1处理b返回c类型
     */
    public static <R, O, V> V or(boolean condition, R a, Function<? super R, ? extends V> function, O b, Function<? super O, ? extends V> function1) {
        return condition ? function.apply(a) : function1.apply(b);
    }

    /**
     * 满足条件执行supplier生产b类型，否则返回b
     * @param condition true / false
     * @param b 其他对象
     * @param supplier 提供者
     * @return true -> 返回b, false -> 生产b类型
     */
    public static <R> R or(boolean condition, R b, Supplier<? extends R> supplier) {
        return condition ? b : supplier.get();
    }

    /**
     * 满足条件执行supplier否则执行supplier1，生产b类型
     * @param condition true / false
     * @param supplier 提供者
     * @param supplier1 提供者1
     * @return true -> 执行supplier生产b类型, false -> 执行supplier1生产b类型
     */
    public static <R> R or(boolean condition, Supplier<? extends R> supplier, Supplier<? extends R> supplier1) {
        return condition ? supplier.get() : supplier1.get();
    }

}