@Override public void leaveCompositeTransform(Node node) { if (transform.getTransform() == node.getTransform()) { tracking = false; } } });
/** Returns the {@link AppliedPTransform} representing this {@link Node}. */ public AppliedPTransform<?, ?, ?> toAppliedPTransform(Pipeline pipeline) { return AppliedPTransform.of( getFullName(), inputs, outputs, (PTransform) getTransform(), pipeline); }
@Override public void leaveCompositeTransform(Node node) { if (node.isRootNode()) { pipelineVisited = true; } }
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode()) { evaluateDisplayData(node.getTransform()); } return CompositeBehavior.ENTER_TRANSFORM; }
@Override public void visitPrimitiveTransform(Node node) { if (node.getTransform() instanceof PAssert.OneSideInputAssert || node.getTransform() instanceof PAssert.GroupThenAssert || node.getTransform() instanceof PAssert.GroupThenAssertForSingleton) { assertCount++; } }
@Override public PTransformReplacement<PCollection<? extends Integer>, PCollection<Integer>> getReplacementTransform( AppliedPTransform< PCollection<? extends Integer>, PCollection<Integer>, MapElements<Integer, Integer>> transform) { return PTransformReplacement.of( PTransformReplacements.getSingletonMainInput(transform), transform.getTransform()); } };
public <OutputT extends POutput> Map<TupleTag<?>, PValue> getOutputs( PTransform<?, OutputT> transform) { return currentTransform.getOutputs(); } }
private void checkForMatches(Node node) { for (PTransformOverride override : overrides) { if (override .getMatcher() .matchesDuringValidation(node.toAppliedPTransform(getPipeline()))) { matched.put(node, override); } } } });
/** * An {@link AppliedPTransform} matched by a {@link PTransformMatcher} will be replaced during * pipeline surgery, and is often expected to be gone the new pipeline. For the {@link * AppliedPTransform} that is expected to remain in the pipeline after surgery, the corresponding * {@link PTransformMatcher} should override this method, such that it will not be matched during * the validation. */ default boolean matchesDuringValidation(AppliedPTransform<?, ?, ?> application) { return matches(application); }
/** * Recursively replace the outputs of the current {@link Node} with the original outputs of the * node it is replacing. No value that is a key in {@code originalToReplacement} may be present * within the {@link TransformHierarchy} after this method completes. */ public void replaceOutputs(Map<PValue, ReplacementOutput> originalToReplacement) { current.replaceOutputs(originalToReplacement); }
public static < InputT extends PInput, OutputT extends POutput, TransformT extends PTransform<? super InputT, OutputT>> AppliedPTransform<InputT, OutputT, TransformT> of( String fullName, Map<TupleTag<?>, PValue> input, Map<TupleTag<?>, PValue> output, TransformT transform, Pipeline p) { return new AutoValue_AppliedPTransform<>(fullName, input, output, transform, p); }
public static <InputT extends PInput, OutputT extends POutput> PTransformReplacement<InputT, OutputT> of( InputT input, PTransform<InputT, OutputT> transform) { return new AutoValue_PTransformOverrideFactory_PTransformReplacement(input, transform); }
public static PTransformOverride of( PTransformMatcher matcher, PTransformOverrideFactory factory) { return new AutoValue_PTransformOverride(matcher, factory); }
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode()) { evaluateDisplayData(node.getTransform()); } return CompositeBehavior.ENTER_TRANSFORM; }
@Override public void visitPrimitiveTransform(TransformHierarchy.Node node) { evaluateDisplayData(node.getTransform()); } }
public <OutputT extends POutput> Map<TupleTag<?>, PValue> getOutputs( PTransform<?, OutputT> transform) { return currentTransform.getOutputs(); }
@Override public void visitPrimitiveTransform(TransformHierarchy.Node node) { evaluateDisplayData(node.getTransform()); } }
public <OutputT extends POutput> Map<TupleTag<?>, PValue> getOutputs( PTransform<?, OutputT> transform) { return currentTransform.getOutputs(); } }
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { assertNotReadTransform(node.getTransform()); return CompositeBehavior.ENTER_TRANSFORM; }