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); }
/** * Returns true if this node represents a composite transform that does not perform processing * of its own, but merely encapsulates a sub-pipeline (which may be empty). * * <p>Note that a node may be composite with no sub-transforms if it returns its input directly * extracts a component of a tuple, or other operations that occur at pipeline assembly time. */ public boolean isCompositeNode() { return !parts.isEmpty() || isRootNode() || returnsOthersOutput(); }
@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; }
@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) { if (node.isRootNode()) { checkState( !pipelineVisited, "Tried to visit a pipeline with an already used %s", AssertionCountingVisitor.class.getSimpleName()); } if (!node.isRootNode() && (node.getTransform() instanceof PAssert.OneSideInputAssert || node.getTransform() instanceof PAssert.GroupThenAssert || node.getTransform() instanceof PAssert.GroupThenAssertForSingleton)) { assertCount++; } return CompositeBehavior.ENTER_TRANSFORM; }
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode() && node.toAppliedPTransform(getPipeline()) .getTransform() .getClass() .equals(Combine.GroupedValues.class)) { transform[0] = node.toAppliedPTransform(getPipeline()); return CompositeBehavior.DO_NOT_ENTER_TRANSFORM; } return CompositeBehavior.ENTER_TRANSFORM; } });
@Test public void getCurrentNoPushReturnsRoot() { assertThat(hierarchy.getCurrent().isRootNode(), is(true)); }
@Override public void leaveCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode()) { parents.removeFirst(); } }
@Override public void leaveCompositeTransform(Node node) { if (!node.isRootNode()) { nameToTransformClass.put(node.getFullName(), node.getTransform().getClass()); } }
@Override public void leaveCompositeTransform(TransformHierarchy.Node node) { PTransform<?, ?> transform = node.getTransform(); if (!node.isRootNode() && transform.getClass().equals(sample.getClass())) { assertTrue(left.add(TransformsSeen.SAMPLE)); } }
@Override public CompositeBehavior enterCompositeTransform(Node node) { if (!node.isRootNode()) { assertThat( node.getTransform().getClass(), not( anyOf( Matchers.equalTo(GenerateSequence.class), Matchers.equalTo(Create.Values.class)))); } return CompositeBehavior.ENTER_TRANSFORM; } });
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode()) { parents.addFirst(node); } return CompositeBehavior.ENTER_TRANSFORM; }
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode()) { evaluateDisplayData(node.getTransform()); } return CompositeBehavior.ENTER_TRANSFORM; }
@Override public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode()) { evaluateDisplayData(node.getTransform()); } return CompositeBehavior.ENTER_TRANSFORM; }
@Override public CompositeBehavior enterCompositeTransform(Node node) { if (!node.isRootNode()) { checkForMatches(node); } if (matched.containsKey(node)) { return CompositeBehavior.DO_NOT_ENTER_TRANSFORM; } else { return CompositeBehavior.ENTER_TRANSFORM; } }
@Override public void leaveCompositeTransform(TransformHierarchy.Node node) { if (!node.isRootNode()) { parents.removeFirst(); } } });
@Override public void leaveCompositeTransform(Node node) { if (node.isRootNode()) { pipelineVisited = true; } }
@Override public String toString() { if (isRootNode()) { return "RootNode"; } return MoreObjects.toStringHelper(getClass()).add("fullName", fullName).toString(); } }
@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); }
@Override public void leaveCompositeTransform(Node node) { if (node.isRootNode()) { checkState( matched.isEmpty(), "Found nodes that matched overrides. Matches: %s", matched); } }