All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • net.cassite.f.For Maven / Gradle / Ivy

    package net.cassite.f;

import io.vertx.core.Future;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class For {
    private For() {
    }

    public static  ForEach each(Iterable it) {
        return new ForEach<>(it.iterator());
    }

    public static  ForEach each(T[] tArr) {
        return new ForEach<>(Arrays.stream(tArr).iterator());
    }

    public static  ForEach each(Iterator ite) {
        return new ForEach<>(ite);
    }

    public static class ForEach {
        private final Iterator ite;

        ForEach(Iterator ite) {
            this.ite = ite;
        }

        public  Future> yield(Function> func) {
            List results = new ArrayList<>();
            return handle(results, func).map(v -> results);
        }

        private  Future handle(List results, Function> func) {
            if (!ite.hasNext())
                return Future.succeededFuture();
            T t = ite.next();
            return func.apply(t).compose(r -> {
                if (r != null) results.add(r);
                return handle(results, func);
            });
        }
    }

    public static  ForLoop init(I initVal) {
        return new ForLoop<>(initVal);
    }

    public static class ForLoopCtx {
        public I i;
    }

    public static class ForLoop {
        private ForLoopCtx ctx = new ForLoopCtx<>();

        ForLoop(I i) {
            ctx.i = i;
        }

        public WithCondition cond(Function, Future> condition) {
            return new WithCondition(condition);
        }

        public WithCondition condSync(Predicate> condition) {
            return new WithCondition(ctx -> Future.succeededFuture(condition.test(ctx)));
        }

        public class WithCondition {
            private final Function, Future> condition;

            WithCondition(Function, Future> condition) {
                this.condition = condition;
            }

            public WithIncr incr(Function, Future> incrFunc) {
                return new WithIncr(incrFunc);
            }

            public WithIncr incrSync(Consumer> incrFunc) {
                return incr(ctx -> {
                    incrFunc.accept(ctx);
                    return Future.succeededFuture();
                });
            }

            public class WithIncr {
                private final Function, Future> incr;

                WithIncr(Function, Future> incr) {
                    this.incr = incr;
                }

                public  Future> yield(Function, Future> func) {
                    List results = new ArrayList<>();
                    return handle(results, func).map(v -> results);
                }

                private  Future handle(List results, Function, Future> func) {
                    return condition.apply(ctx).compose(b -> {
                        if (!b) return Future.succeededFuture();
                        return func.apply(ctx).compose(r -> {
                            if (r != null) results.add(r);
                            return incr.apply(ctx);
                        }).compose(v -> handle(results, func));
                    });
                }
            }
        }
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy