@Override public void visitPrimitiveTransform(Node node) { if (freedNodes.contains(node.getEnclosingNode())) { freedNodes.add(node); } else if (override.getMatcher().matches(node.toAppliedPTransform(getPipeline()))) { matches.add(node); freedNodes.add(node); } } });
private boolean shouldDebug(final TransformHierarchy.Node node) { return node == null || (!transforms .stream() .anyMatch( debugTransform -> debugTransform.getNode().equals(node) && debugTransform.isComposite()) && shouldDebug(node.getEnclosingNode())); }
@Override public CompositeBehavior enterCompositeTransform(Node node) { if (!node.isRootNode() && freedNodes.contains(node.getEnclosingNode())) { // This node will be freed because its parent will be freed. freedNodes.add(node); return CompositeBehavior.ENTER_TRANSFORM; } if (!node.isRootNode() && override.getMatcher().matches(node.toAppliedPTransform(getPipeline()))) { matches.add(node); // This node will be freed. When we visit any of its children, they will also be freed freedNodes.add(node); } return CompositeBehavior.ENTER_TRANSFORM; }
Set<Node> visitedNodes, Set<Node> skippedComposites) { if (getEnclosingNode() != null && !visitedNodes.contains(getEnclosingNode())) { getEnclosingNode().visit(visitor, visitedValues, visitedNodes, skippedComposites);
assertThat(compositeNode.getEnclosingNode().isRootNode(), is(true)); assertThat(primitiveNode.getInputs().entrySet(), Matchers.emptyIterable()); assertThat(primitiveNode.getTransform(), equalTo(read)); assertThat(primitiveNode.getEnclosingNode(), equalTo(compositeNode));
assertThat(replacement.getEnclosingNode(), equalTo(original.getEnclosingNode())); assertThat(replacement.getEnclosingNode(), equalTo(enclosing)); assertThat(replacement.getTransform(), equalTo(replacementTransform));
"Replacing a node when the graph has an unexpanded input. This is an SDK bug."); Node replacement = new Node(existing.getEnclosingNode(), transform, existing.getFullName(), input); for (PValue output : existing.getOutputs().values()) { Node producer = producers.get(output); producedInExisting = true; } else { producer = producer.getEnclosingNode(); existing.getEnclosingNode().replaceChild(existing, replacement); unexpandedInputs.remove(existing); unexpandedInputs.put(replacement, input);
@Override public void leaveCompositeTransform(Node node) { if (node.isRootNode()) { for (AppliedPTransform<?, ?, ?> pipelineRoot : children.get(node)) { rootIds.add(components.getExistingPTransformId(pipelineRoot)); } } else { // TODO: Include DisplayData in the proto children.put(node.getEnclosingNode(), node.toAppliedPTransform(pipeline)); try { components.registerPTransform( node.toAppliedPTransform(pipeline), children.get(node)); } catch (IOException e) { throw new RuntimeException(e); } } }
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { if (node.isRootNode()) { return CompositeBehavior.ENTER_TRANSFORM; } PTransform<?, ?> transform = node.getTransform(); if (sample.getClass().equals(transform.getClass())) { assertTrue(visited.add(TransformsSeen.SAMPLE)); assertNotNull(node.getEnclosingNode()); assertTrue(node.isCompositeNode()); } else if (transform instanceof WriteFiles) { assertTrue(visited.add(TransformsSeen.WRITE)); assertNotNull(node.getEnclosingNode()); assertTrue(node.isCompositeNode()); } assertThat(transform, not(instanceOf(Read.Bounded.class))); return CompositeBehavior.ENTER_TRANSFORM; }
@Override public CompositeBehavior enterCompositeTransform(Node node) { for (PValue input : node.getInputs().values()) { assertThat(visitedValues, hasItem(input)); } assertThat( "Nodes should not be visited more than once", visitedNodes, not(hasItem(node))); if (!node.isRootNode()) { assertThat( "Nodes should always be visited after their enclosing nodes", visitedNodes, hasItem(node.getEnclosingNode())); } visitedNodes.add(node); return CompositeBehavior.ENTER_TRANSFORM; }
@Override public void visitPrimitiveTransform(Node node) { // TODO: Include DisplayData in the proto children.put(node.getEnclosingNode(), node.toAppliedPTransform(pipeline)); try { components.registerPTransform( node.toAppliedPTransform(pipeline), Collections.emptyList()); } catch (IOException e) { throw new IllegalStateException(e); } } });
/** * Pops the current node off the top of the stack, finishing it. Outputs of the node are finished * once they are consumed as input. */ public void popNode() { current.finishSpecifying(); unexpandedInputs.remove(current); current = current.getEnclosingNode(); checkState(current != null, "Can't pop the root node of a TransformHierarchy"); }
@Override public void visitPrimitiveTransform(Node node) { assertThat(visitedNodes, hasItem(node.getEnclosingNode())); assertThat(exitedNodes, not(hasItem(node.getEnclosingNode()))); assertThat( "Nodes should not be visited more than once", visitedNodes, not(hasItem(node))); for (PValue input : node.getInputs().values()) { assertThat(visitedValues, hasItem(input)); } visitedNodes.add(node); }
private boolean childNodeOf(Set<Node> nodes) { if (isRootNode()) { return false; } Node parent = this.getEnclosingNode(); while (!parent.isRootNode() && !nodes.contains(parent)) { parent = parent.getEnclosingNode(); } return nodes.contains(parent); }
@Override public void visitPrimitiveTransform(TransformHierarchy.Node node) { PTransform<?, ?> transform = node.getTransform(); // Pick is a composite, should not be visited here. assertThat(transform, not(instanceOf(Combine.Globally.class))); assertThat(transform, not(instanceOf(WriteFiles.class))); if (transform instanceof Read.Bounded && node.getEnclosingNode().getTransform() instanceof TextIO.Read) { assertTrue(visited.add(TransformsSeen.READ)); } } });
@Override public void leaveCompositeTransform(Node node) { assertThat(visitedNodes, hasItem(node)); if (!node.isRootNode()) { assertThat( "Nodes should always be left before their enclosing nodes are left", exitedNodes, not(hasItem(node.getEnclosingNode()))); } assertThat(exitedNodes, not(hasItem(node))); exitedNodes.add(node); }