/** * Appends a concrete, native protocol to the list of producers - useful for the native protocol * factories that needs to be builders. * * @param nativeProtocol the native protocol to add * @param <T> the result type of the native protocol * @return a computation that resolves to the result of the native protocol once evaluated */ public <T> DRes<T> append(NativeProtocol<T, ?> nativeProtocol) { SingleProtocolProducer<T> producer = new SingleProtocolProducer<>(nativeProtocol); createAndAppend(producer); return producer; }
@Override public DRes<List<byte[]>> buildComputation(BuilderT builder) { return builder.par(par -> { List<DRes<List<byte[]>>> broadcastValues = new ArrayList<>(); for (byte[] singleInput : input) { broadcastValues.add(par.append(new InsecureBroadcastProtocol<>(singleInput))); } return () -> broadcastValues; }).seq((seq, lst) -> { List<byte[]> toValidate = lst.stream() .flatMap(broadcast -> broadcast.out().stream()) .collect(Collectors.toList()); seq.append(new BroadcastValidationProtocol<>(toValidate)); return () -> toValidate; }); }
private void updateToNextProducer(InputT input) { if (doneWithOwn) { isDone = true; } else { if (predicate.test(input)) { BuilderT builder = factory.createSequential(); currentResult = function.buildComputation(builder, input); currentProducer = builder.build(); } else { doneWithOwn = true; if (next != null) { currentProducer = next.createProducer(input, factory); next = null; } } } }
/** * 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; }
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 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 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; } }