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

Go to download
package net.cassite.f;

import io.vertx.core.Future;
import org.jetbrains.annotations.NotNull;

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

/**
 * a container, store data inside the container
 *
 * @param  type of the Ptr
 */
public class Ptr implements ReadablePtr>, WritablePtr, AsTransformable> {
    private Supplier getter;
    private Consumer setter;

    private Ptr(Supplier getter, Consumer setter) {
        this.getter = getter;
        this.setter = setter;
    }

    @SuppressWarnings("unchecked")
    public static  Ptr nil() {
        Object[] t = new Object[]{null};
        return new Ptr<>(() -> (T) t[0], v -> t[0] = v);
    }

    @SuppressWarnings("unchecked")
    public static  Ptr of(@NotNull T value) {
        if (value == null)
            throw new NullPointerException();
        Object[] t = new Object[]{value};
        return new Ptr<>(() -> (T) t[0], v -> t[0] = v);
    }

    public static  Ptr of(@NotNull Supplier getter, @NotNull Consumer setter) {
        if (getter == null)
            throw new NullPointerException();
        if (setter == null)
            throw new NullPointerException();
        return new Ptr<>(getter, setter);
    }

    @SuppressWarnings("unchecked")
    public static  ReadablePtr ofReadonly(@NotNull T value) {
        if (value == null)
            throw new NullPointerException();
        Object[] t = new Object[]{value};
        return new Ptr<>(() -> (T) t[0], v -> {
            throw new UnsupportedOperationException();
        });
    }

    @Override
    public T get() {
        return getter.get();
    }

    @Override
    public Ptr store(@NotNull T t) {
        if (t == null)
            throw new NullPointerException();
        setter.accept(t);
        return this;
    }

    @Override
    public Ptr storeNil() {
        setter.accept(null);
        return this;
    }

    @Override
    public Monad store(@NotNull Future fu) {
        if (fu == null)
            throw new NullPointerException();
        Monad tbd = F.tbd();
        fu.setHandler(r -> {
            if (r.failed()) {
                tbd.fail(r.cause());
            } else {
                T value = r.result();
                setter.accept(value);
                if (value == null) {
                    tbd.complete();
                } else {
                    tbd.complete(value);
                }
            }
        });
        return tbd;
    }

    @Override
    public  Monad unary(@NotNull Function, Future> f) {
        if (f == null)
            throw new NullPointerException();
        return Monad.transform(f.apply(this));
    }

    @Override
    public  Monad bin(@NotNull BiFunction, Future, Future> f, @NotNull Future fu) {
        if (f == null)
            throw new NullPointerException();
        if (fu == null)
            throw new NullPointerException();
        return Monad.transform(f.apply(this, fu));
    }

    // --------- begin primitive transformer -----------
    public static final Misc.IntFunction> Int = ReadablePtr::get;

    public static final Misc.FloatFunction> Float = ReadablePtr::get;

    public static final Misc.LongFunction> Long = ReadablePtr::get;

    public static final Misc.DoubleFunction> Double = ReadablePtr::get;

    public static final Misc.ShortFunction> Short = ReadablePtr::get;

    public static final Misc.ByteFunction> Byte = ReadablePtr::get;

    public static final Misc.BoolFunction> Bool = ReadablePtr::get;

    public static final Misc.CharFunction> Char = ReadablePtr::get;
    // --------- end primitive transformer -----------
}