vertx.effect.exp.IfElse Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vertx-effect Show documentation
When actors meet Functional Programming
There is a newer version: 5.0.0
package vertx.effect.exp;

import io.vertx.core.Future;
import vertx.effect.RetryPolicy;
import vertx.effect.core.AbstractVal;
import vertx.effect.Val;

import java.util.function.BiFunction;
import java.util.function.Predicate;

import static java.util.Objects.requireNonNull;

public final class IfElse extends AbstractVal {

    private final Val predicate;
    private static final String ATTEMPTS_LOWER_THAN_ONE_ERROR = "attempts < 1";
    private Val consequence;
    private Val alternative;

    public static  IfElse predicate(Val predicate) {
        return new IfElse<>(requireNonNull(predicate));
    }

    public static  IfElse predicate(boolean bool) {
        return new IfElse<>(requireNonNull(Cons.success(bool)));
    }

    IfElse(final Val predicate) {
        this.predicate = requireNonNull(predicate);
    }

    public IfElse consequence(final Val consequence) {
        this.consequence = requireNonNull(consequence);
        return this;
    }

    public IfElse alternative(final Val alternative) {
        this.alternative = requireNonNull(alternative);
        return this;
    }


    @Override
    public Future get() {
        final Future futureCon = predicate.get();
        return futureCon.flatMap(c -> {
            if (Boolean.TRUE.equals(c)) return consequence.get();
            else return alternative.get();
        });
    }


    @Override
    public Val retry(final int attempts) {
        if (attempts < 1)
            return Cons.failure(new IllegalArgumentException(ATTEMPTS_LOWER_THAN_ONE_ERROR));
        return new IfElse(predicate.retry(attempts))
                .consequence(consequence.retry(attempts))
                .alternative(alternative.retry(attempts));
    }


    @Override
    public Val retry(final int attempts,
                        final BiFunction> retryPolicy) {
        if (attempts < 1)
            return Cons.failure(new IllegalArgumentException(ATTEMPTS_LOWER_THAN_ONE_ERROR));
        return new IfElse(predicate.retry(attempts,
                                             retryPolicy
                                            ))
                .consequence(consequence.retry(attempts,
                                               retryPolicy
                                              ))
                .alternative(alternative.retry(attempts,
                                               retryPolicy
                                              ));
    }

    @Override
    public Val retry(final Predicate predicate,
                        final int attempts) {
        if (attempts < 1)
            return Cons.failure(new IllegalArgumentException(ATTEMPTS_LOWER_THAN_ONE_ERROR));
        if (predicate == null)
            return Cons.failure(new NullPointerException("predicate is null"));
        return new IfElse(this.predicate.retry(predicate,
                                                  attempts
                                                 ))
                .consequence(consequence.retry(predicate,
                                               attempts
                                              ))
                .alternative(alternative.retry(predicate,
                                               attempts
                                              ));
    }

    @Override
    public Val retry(final Predicate predicate,
                        final int attempts,
                        final RetryPolicy retryPolicy) {

        if (attempts < 1)
            return Cons.failure(new IllegalArgumentException(ATTEMPTS_LOWER_THAN_ONE_ERROR));
        if (predicate == null)
            return Cons.failure(new NullPointerException("predicate is null"));
        if (retryPolicy == null)
            return Cons.failure(new NullPointerException("retryPolicy is null"));
        return new IfElse(this.predicate.retry(predicate,
                                                  attempts,
                                                  retryPolicy
                                                 ))
                .consequence(consequence.retry(predicate,
                                               attempts,
                                               retryPolicy
                                              ))
                .alternative(alternative.retry(predicate,
                                               attempts,
                                               retryPolicy
                                              ));
    }

}