net.cassite.f.Monad Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of f Show documentation
a library to write async vert.x code similar as using java syntax
The newest version!
package net.cassite.f;

import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import net.cassite.f.core.MonadLike;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.function.*;

/**
 * the monad instance of this library

 * now it's adapted to vertx Future ({@link Future}) and can be used in the vertx world
 *
 * @param  the type
 */
public class Monad<@Nullable T> implements Future, MonadLike, AsTransformable> {
    private final Future vertxFuture;

    Monad(Future vertxFuture) {
        this.vertxFuture = vertxFuture;
    }

    static  Monad transform(Future f) {
        if (f instanceof Monad) {
            return (Monad) f;
        } else {
            return new Monad<>(f);
        }
    }

    public static  Monad unit(@Nullable E e) {
        return new Monad<>(Future.succeededFuture(e));
    }

    public static  Monad unit() {
        return new Monad<>(Future.succeededFuture());
    }

    private Monad transformMaybeSelf(Future resultF) {
        if (resultF == vertxFuture) {
            return this;
        } else {
            return transform(resultF);
        }
    }

    private  Function> mapperAvoidNull(Function> mapper) {
        return a -> {
            Future b = mapper.apply(a);
            if (b == null)
                throw new NullPointerException();
            return b;
        };
    }

    @Override
    public boolean isComplete() {
        return vertxFuture.isComplete();
    }

    @Override
    public Monad setHandler(@NotNull Handler> handler) {
        if (handler == null)
            throw new NullPointerException();
        return transformMaybeSelf(vertxFuture.setHandler(handler));
    }

    @Override
    public void complete(@Nullable T result) {
        vertxFuture.complete(result);
    }

    @Override
    public void complete() {
        vertxFuture.complete();
    }

    @Override
    public void fail(@NotNull Throwable cause) {
        if (cause == null)
            throw new NullPointerException();
        vertxFuture.fail(cause);
    }

    @Override
    public void fail(@NotNull String failureMessage) {
        if (failureMessage == null)
            throw new NullPointerException();
        vertxFuture.fail(failureMessage);
    }

    @Override
    public boolean tryComplete(@Nullable T result) {
        return vertxFuture.tryComplete(result);
    }

    @Override
    public boolean tryComplete() {
        return vertxFuture.tryComplete();
    }

    @Override
    public boolean tryFail(@NotNull Throwable cause) {
        if (cause == null)
            throw new NullPointerException();
        return vertxFuture.tryFail(cause);
    }

    @Override
    public boolean tryFail(@NotNull String failureMessage) {
        if (failureMessage == null)
            throw new NullPointerException();
        return vertxFuture.tryFail(failureMessage);
    }

    @Override
    @Nullable
    public T result() {
        return vertxFuture.result();
    }

    @Override
    @Nullable
    public Throwable cause() {
        return vertxFuture.cause();
    }

    @Override
    public boolean succeeded() {
        return vertxFuture.succeeded();
    }

    @Override
    public boolean failed() {
        return vertxFuture.failed();
    }

    @Override
    public void handle(@NotNull AsyncResult asyncResult) {
        if (asyncResult == null)
            throw new NullPointerException();
        vertxFuture.handle(asyncResult);
    }

    @Override
    public  Monad compose(@NotNull Handler handler, @NotNull Future next) {
        if (handler == null)
            throw new NullPointerException();
        if (next == null)
            throw new NullPointerException();
        return transform(vertxFuture.compose(handler, next));
    }

    @Override
    public  Monad compose(@NotNull Function> mapper) {
        if (mapper == null)
            throw new NullPointerException();
        return transform(vertxFuture.compose(mapperAvoidNull(mapper)));
    }

    public  Monad compose(@NotNull Supplier<@NotNull Future> mapper) {
        if (mapper == null)
            throw new NullPointerException();
        return compose(v -> {
            Future fu = mapper.get();
            if (fu == null)
                throw new NullPointerException();
            return fu;
        });
    }

    @Override
    public  Monad map(@NotNull Function mapper) {
        if (mapper == null)
            throw new NullPointerException();
        return transform(vertxFuture.map(mapper));
    }

    @Override
    public  Monad map(@Nullable V value) {
        return transform(vertxFuture.map(value));
    }

    public  Monad map(@NotNull Supplier<@Nullable U> supplier) {
        if (supplier == null)
            throw new NullPointerException();
        return map(v -> supplier.get());
    }

    @Override
    public  Monad mapEmpty() {
        return transform(vertxFuture.mapEmpty());
    }

    public  Monad mapEmpty(@NotNull Consumer consumer) {
        if (consumer == null)
            throw new NullPointerException();
        return map(t -> {
            consumer.accept(t);
            return null;
        });
    }

    public  Monad mapEmpty(@NotNull Runnable code) {
        if (code == null)
            throw new NullPointerException();
        return map(t -> {
            code.run();
            return null;
        });
    }

    public Monad bypass(@NotNull Runnable code) {
        if (code == null)
            throw new NullPointerException();
        return map(t -> {
            code.run();
            return t;
        });
    }

    @Override
    public Handler> completer() {
        return vertxFuture.completer();
    }

    @Override
    public Monad recover(@NotNull Function> mapper) {
        if (mapper == null)
            throw new NullPointerException();
        return transformMaybeSelf(vertxFuture.recover(mapperAvoidNull(mapper)));
    }

    @Override
    public Monad otherwise(@NotNull Function mapper) {
        if (mapper == null)
            throw new NullPointerException();
        return transformMaybeSelf(vertxFuture.otherwise(mapper));
    }

    @Override
    public Monad otherwise(@Nullable T value) {
        return transformMaybeSelf(vertxFuture.otherwise(value));
    }

    @Override
    public Monad otherwiseEmpty() {
        return transformMaybeSelf(vertxFuture.otherwiseEmpty());
    }
}