/** * Creates a new Build step based on this builder but with a subsequent parallel producer inserted * after the original protocol producer. * * @param function of the protocol producer - will be lazy evaluated */ public <NextOutputT> BuildStep<OutputT, BuilderT, NextOutputT> par( FrescoLambdaParallel<OutputT, BuilderT, NextOutputT> function) { BuildStep<OutputT, BuilderT, NextOutputT> localChild = new BuildStep<>(new BuildStepSingle<>(function, true)); this.next = localChild; return localChild; }
public Pair<ProtocolProducer, DRes<OutputT>> createNextStep( InputT input, BuilderFactory<BuilderT> factory, BuildStep<OutputT, BuilderT, ?> next) { BuilderT builder = createBuilder(factory); DRes<OutputT> output = function.buildComputation(builder, input); if (next != null) { List<ProtocolProducer> protocols = Arrays.asList( builder.build(), new LazyProtocolProducerDecorator(() -> { OutputT out = null; if (output != null) { out = output.out(); } return next.createProducer(out, factory); })); SequentialProtocolProducer protocolProducer = new SequentialProtocolProducer(protocols); return new Pair<>(protocolProducer, null); } else { return new Pair<>(builder.build(), output); } }
/** * Creates a new Build step based on this builder but with a subsequent producer inserted after * the original protocol producer. * * @param function creation of the protocol producer - will be lazy evaluated */ public <NextOutputT> BuildStep<OutputT, BuilderT, NextOutputT> seq( FrescoLambda<OutputT, BuilderT, NextOutputT> function) { BuildStep<OutputT, BuilderT, NextOutputT> localChild = new BuildStep<>(new BuildStepSingle<>(function, false)); this.next = localChild; return localChild; }
/** * Creates a new Build step based on this builder but with a nested parallel protocol * producer inserted into the original protocol producer. * * @param f of the protocol producer - will be lazy evaluated */ public <R> BuildStep<Void, BuilderT, R> par(ComputationParallel<R, BuilderT> f) { FrescoLambda<Void, BuilderT, R> innerBuilder = (inner, ignored) -> f.buildComputation(inner); BuildStep<Void, BuilderT, R> builder = new BuildStep<>(new BuildStepSingle<>(innerBuilder, true)); createAndAppend(new LazyProtocolProducerDecorator(() -> builder.createProducer(null, factory))); return builder; } }
/** * Creates a new Build step based on this builder but with a nested sequential protocol * producer inserted into the original protocol producer. * * @param function creation of the protocol producer - will be lazy evaluated */ public <R> BuildStep<Void, BuilderT, R> seq(Computation<R, BuilderT> function) { FrescoLambda<Void, BuilderT, R> innerBuilder = (inner, ignored) -> function.buildComputation(inner); BuildStep<Void, BuilderT, R> builder = new BuildStep<>(new BuildStepSingle<>(innerBuilder, false)); createAndAppend(new LazyProtocolProducerDecorator(() -> builder.createProducer(null, factory))); return builder; }
/** * Creates a new Build step based on this builder but with a subsequent producer inserted after * the original protocol producer. The two producer will be evalueted in parallel, however each * of the two functions will be evaluated in sequence. * * @param firstFunction of the first protocol producer - will be lazy evaluated * @param secondFunction of the second protocol producer - will be lazy evaluated */ public <FirstOutputT, SecondOutputT> BuildStep<OutputT, BuilderT, Pair<FirstOutputT, SecondOutputT>> pairInPar( FrescoLambda<OutputT, BuilderT, FirstOutputT> firstFunction, FrescoLambda<OutputT, BuilderT, SecondOutputT> secondFunction) { BuildStep<OutputT, BuilderT, Pair<FirstOutputT, SecondOutputT>> localChild = new BuildStep<>( new BuildStepSingle<>( (BuilderT builder, OutputT output1) -> { DRes<FirstOutputT> firstOutput = builder.seq( seq -> firstFunction.buildComputation(seq, output1)); DRes<SecondOutputT> secondOutput = builder.seq( seq -> secondFunction.buildComputation(seq, output1)); return () -> new Pair<>(firstOutput.out(), secondOutput.out()); }, true) ); this.next = localChild; return localChild; }