public <OutputT extends POutput> Map<TupleTag<?>, PValue> getOutputs( PTransform<?, OutputT> transform) { return currentTransform.getOutputs(); } }
public <OutputT extends POutput> Map<TupleTag<?>, PValue> getOutputs( PTransform<?, OutputT> transform) { return currentTransform.getOutputs(); }
@Override public Collection<PValue> getProduced(AppliedPTransform<?, ?, ?> producer) { // TODO: This must only be called on primitive transforms; composites should return empty // values. return producer.getOutputs().values(); }
@Override public <OutputT extends POutput> Map<TupleTag<?>, PValue> getOutputs( PTransform<?, OutputT> transform) { return getCurrentTransform(transform).getOutputs(); }
public Map<TupleTag<?>, Coder<?>> getOutputCoders() { return currentTransform .getOutputs() .entrySet() .stream() .filter(e -> e.getValue() instanceof PCollection) .collect(Collectors.toMap(e -> e.getKey(), e -> ((PCollection) e.getValue()).getCoder())); }
public Map<TupleTag<?>, Coder<?>> getOutputCoders() { return currentTransform .getOutputs() .entrySet() .stream() .filter(e -> e.getValue() instanceof PCollection) .collect(Collectors.toMap(e -> e.getKey(), e -> ((PCollection) e.getValue()).getCoder())); }
/** * @param ptransform PTransform to get coders for its outputs * @return the output coders. */ private static Map<TupleTag<?>, Coder<?>> getOutputCoders(final AppliedPTransform<?, ?, ?> ptransform) { return ptransform .getOutputs() .entrySet() .stream() .filter(e -> e.getValue() instanceof PCollection) .collect(Collectors.toMap(e -> e.getKey(), e -> ((PCollection) e.getValue()).getCoder())); }
private boolean hasUnboundedOutput(AppliedPTransform<?, ?, ?> transform) { return transform .getOutputs() .values() .stream() .filter(value -> value instanceof PCollection) .map(value -> (PCollection<?>) value) .anyMatch(collection -> collection.isBounded() == IsBounded.UNBOUNDED); }
public Map<TupleTag<?>, Coder<?>> getOutputCoders() { return currentTransform .getOutputs() .entrySet() .stream() .filter(e -> e.getValue() instanceof PCollection) .collect(Collectors.toMap(e -> e.getKey(), e -> ((PCollection) e.getValue()).getCoder())); }
@SuppressWarnings("unchecked") <T extends PValue> T getOutput(PTransform<?, T> transform) { return (T) Iterables.getOnlyElement(currentTransform.getOutputs().values()); } }
public static <T> PCollection<T> getSingletonMainOutput( AppliedPTransform<?, PCollection<T>, ? extends PTransform<?, PCollection<T>>> transform) { return (PCollection<T>) Iterables.getOnlyElement(transform.getOutputs().values()); } }
public static Map<TupleTag<?>, Coder<?>> getOutputCoders(AppliedPTransform<?, ?, ?> application) { return application .getOutputs() .entrySet() .stream() .filter(e -> e.getValue() instanceof PCollection) .collect(Collectors.toMap(e -> e.getKey(), e -> ((PCollection) e.getValue()).getCoder())); }
@SuppressWarnings("unchecked") <T extends PValue> T getOutput(PTransform<?, T> transform) { return (T) Iterables.getOnlyElement(currentTransform.getOutputs().values()); } }
private boolean hasUnboundedOutput(AppliedPTransform<?, ?, ?> transform) { return transform .getOutputs() .values() .stream() .filter(value -> value instanceof PCollection) .map(value -> (PCollection<?>) value) .anyMatch(collection -> collection.isBounded() == IsBounded.UNBOUNDED); }
public Map<TupleTag<?>, PValue> getOutputs(PTransform<?, ?> transform) { checkArgument(currentTransform != null, "can only be called with non-null currentTransform"); checkArgument( currentTransform.getTransform() == transform, "can only be called with current transform"); return currentTransform.getOutputs(); }
@Override public void processElement(WindowedValue<ImpulseShard> element) throws Exception { PCollection<byte[]> outputPCollection = (PCollection<byte[]>) Iterables.getOnlyElement(transform.getOutputs().values()); result.addOutput( ctxt.createBundle(outputPCollection).add(WindowedValue.valueInGlobalWindow(new byte[0]))); }
private <InputT> TransformEvaluator<InputT> createTransformEvaluator( AppliedPTransform<PCollection<InputT>, PCollection<InputT>, Window.Assign<InputT>> transform) { WindowFn<? super InputT, ?> fn = (WindowFn) WindowIntoTranslation.getWindowFn(transform); UncommittedBundle<InputT> outputBundle = evaluationContext.createBundle( (PCollection<InputT>) Iterables.getOnlyElement(transform.getOutputs().values())); if (fn == null) { return PassthroughTransformEvaluator.create(transform, outputBundle); } return new WindowIntoEvaluator<>(transform, fn, outputBundle); }
@Override public PTransformReplacement<PBegin, PCollection<T>> getReplacementTransform( AppliedPTransform<PBegin, PCollection<T>, Create.Values<T>> transform) { Create.Values<T> original = transform.getTransform(); PCollection<T> output = (PCollection) Iterables.getOnlyElement(transform.getOutputs().values()); return PTransformReplacement.of( transform.getPipeline().begin(), new StreamingFnApiCreate<>(original, output)); }
private <InputT> TransformEvaluator<InputT> createInMemoryEvaluator( final AppliedPTransform<PCollectionList<InputT>, PCollection<InputT>, PCollections<InputT>> application) { final UncommittedBundle<InputT> outputBundle = evaluationContext.createBundle( (PCollection<InputT>) Iterables.getOnlyElement(application.getOutputs().values())); final TransformResult<InputT> result = StepTransformResult.<InputT>withoutHold(application).addOutput(outputBundle).build(); return new FlattenEvaluator<>(outputBundle, result); }
@Override public PTransformReplacement<PBegin, PCollection<T>> getReplacementTransform( AppliedPTransform<PBegin, PCollection<T>, Values<T>> transform) { return PTransformReplacement.of( transform.getPipeline().begin(), new PrimitiveCreate<>( transform.getTransform(), ((PCollection<T>) Iterables.getOnlyElement(transform.getOutputs().values())) .getCoder())); }