Uses of Class
org.jenkinsci.plugins.workflow.graph.FlowNode

Packages that use FlowNode

Package	Description
org.jenkinsci.plugins.workflow.actions
org.jenkinsci.plugins.workflow.flow
org.jenkinsci.plugins.workflow.graph
org.jenkinsci.plugins.workflow.graphanalysis	Provides a library of methods to work with and analyze the graph of FlowNodes produced from a pipeline execution.
org.jenkinsci.plugins.workflow.log	APIs supporting the production and retrieval of log messages associated with Pipeline builds (FlowExecutionOwner) and individual steps (FlowNode).

Uses of FlowNode in org.jenkinsci.plugins.workflow.actions

Methods in org.jenkinsci.plugins.workflow.actions that return FlowNode

Modifier and Type	Method	Description
static FlowNode	ErrorAction.findOrigin(Throwable error, FlowExecution execution)	Attempts to locate the first node of a build which threw an error.

Methods in org.jenkinsci.plugins.workflow.actions that return types with arguments of type FlowNode

Modifier and Type	Method	Description
abstract AnnotatedLargeText<? extends FlowNode>	LogAction.getLogText()	Access the log file and expose it to the UI with the progressive logging functionality

Methods in org.jenkinsci.plugins.workflow.actions with parameters of type FlowNode

Modifier and Type	Method	Description
static Map<String,Object>	ArgumentsAction.getArguments(FlowNode n)	Get the map of arguments supplied to instantiate the Step run in the FlowNode given or empty if the arguments were not stored or the FlowNode was not a step.
static Map<String,Object>	ArgumentsAction.getFilteredArguments(FlowNode n)	Get just the fully stored, non-null arguments This means the arguments with all ArgumentsAction.NotStoredReason or null values removed
static QueueItemAction.QueueState	QueueItemAction.getNodeState(FlowNode node)	Get the current QueueItemAction.QueueState for a FlowNode.
static Queue.Item	QueueItemAction.getQueueItem(FlowNode node)
static Map<String,?>	ArgumentsAction.getResolvedArguments(FlowNode n)	Like ArgumentsAction.getArguments(FlowNode) but attempting to resolve actual classes.
static long	TimingAction.getStartTime(FlowNode flowNode)
static String	ArgumentsAction.getStepArgumentsAsString(FlowNode n)	Return a tidy string description for the step arguments, or null if none is present or we can't make one See StepDescriptor.argumentsToString(Map) for the rules
static Map<String,String>	TagsAction.getTags(FlowNode node)	Get the set of tag-value mappings for a node
static String	TagsAction.getTagValue(FlowNode node, String tag)	Get the value for a tag on a flownode, null if not set (convenience) Input is CheckForNull so you can directly pass in values without nullchecks upfront.
static boolean	NotExecutedNodeAction.isExecuted(FlowNode node)
void	BodyInvocationAction.onLoad(FlowNode parent)
void	FlowNodeAction.onLoad(FlowNode parent)	Called by FlowActionStorage.loadActions(FlowNode) when actions get loaded from persistent storage.

Uses of FlowNode in org.jenkinsci.plugins.workflow.flow

Methods in org.jenkinsci.plugins.workflow.flow that return FlowNode

Modifier and Type	Method	Description
abstract FlowNode	FlowExecution.getNode(String id)	Loads a node by its ID.

Methods in org.jenkinsci.plugins.workflow.flow that return types with arguments of type FlowNode

Modifier and Type	Method	Description
abstract List<FlowNode>	FlowExecution.getCurrentHeads()	In the current flow graph, return all the "head" nodes where the graph is still growing.

Methods in org.jenkinsci.plugins.workflow.flow with parameters of type FlowNode

Modifier and Type	Method	Description
List<BlockStartNode>	FlowExecution.findAllEnclosingBlockStarts(FlowNode node)
BlockStartNode	FlowExecution.findEnclosingBlockStart(FlowNode node)
boolean	FlowExecution.isActive(FlowNode node)
abstract boolean	FlowExecution.isCurrentHead(FlowNode n)	Short for getCurrentHeads().contains(n) but more efficient.
Iterable<BlockStartNode>	FlowExecution.iterateEnclosingBlocks(FlowNode node)
void	GraphListener.onNewHead(FlowNode node)	FlowExecution should batch up changes to a group and call this once, as opposed to call this for every new node added.

Uses of FlowNode in org.jenkinsci.plugins.workflow.graph

Subclasses of FlowNode in org.jenkinsci.plugins.workflow.graph

Modifier and Type	Class	Description
class	AtomNode	FlowNode that has no further FlowNodes inside.
class	BlockEndNode<START extends BlockStartNode>	End of a block.
class	BlockStartNode	Together with BlockEndNode, designates some kind of nested structure that contains "children", which are FlowNodes that are in between BlockStartNode and BlockEndNode
class	FlowEndNode	End of the entire program.
class	FlowStartNode	Start of the entire flow.
class	ForkNode	Deprecated. unused
class	JoinNode	Deprecated. unused

Methods in org.jenkinsci.plugins.workflow.graph that return FlowNode

Modifier and Type	Method	Description
FlowNode	FlowGraphWalker.next()	Deprecated. This class is Iterable now.

Methods in org.jenkinsci.plugins.workflow.graph that return types with arguments of type FlowNode

Modifier and Type	Method	Description
List<FlowNode>	FlowNode.getParents()	Returns a read-only view of parents.
List<FlowNode>	FlowStartNode.getParents()	Deprecated. Why are you calling a method that always return empty list?
Iterator<FlowNode>	FlowGraphWalker.iterator()	Unlike Iterable.iterator(), this may be iterated only once.

Methods in org.jenkinsci.plugins.workflow.graph with parameters of type FlowNode

Modifier and Type	Method	Description
void	FlowGraphWalker.addHead(FlowNode head)
List<BlockStartNode>	GraphLookupView.findAllEnclosingBlockStarts(FlowNode node)	Return all enclosing block start nodes, as with GraphLookupView.findEnclosingBlockStart(FlowNode).
List<BlockStartNode>	StandardGraphLookupView.findAllEnclosingBlockStarts(FlowNode node)
BlockStartNode	GraphLookupView.findEnclosingBlockStart(FlowNode node)	Find the immediately enclosing BlockStartNode around a FlowNode
BlockStartNode	StandardGraphLookupView.findEnclosingBlockStart(FlowNode node)
boolean	GraphLookupView.isActive(FlowNode node)	Tests if the node is a currently running head, or the start of a block that has not completed executing
boolean	StandardGraphLookupView.isActive(FlowNode node)
Iterable<BlockStartNode>	GraphLookupView.iterateEnclosingBlocks(FlowNode node)	Provide an Iterable over all enclosing blocks, which can be used similarly to GraphLookupView.findAllEnclosingBlockStarts(FlowNode) but does lazy fetches rather than materializing a full result.
Iterable<BlockStartNode>	StandardGraphLookupView.iterateEnclosingBlocks(FlowNode node)
List<Action>	FlowActionStorage.loadActions(FlowNode node)	Service for FlowNode to load its actions.
void	StandardGraphLookupView.onNewHead(FlowNode newHead)	Update with a new node added to the flowgraph
void	FlowActionStorage.saveActions(FlowNode node, List<Action> actions)	Service for FlowNode to load its actions.

Method parameters in org.jenkinsci.plugins.workflow.graph with type arguments of type FlowNode

Modifier and Type	Method	Description
void	FlowGraphWalker.addHeads(List<FlowNode> heads)

Constructors in org.jenkinsci.plugins.workflow.graph with parameters of type FlowNode

Modifier	Constructor	Description
protected	AtomNode(FlowExecution exec, String id, FlowNode... parents)
	BlockEndNode(FlowExecution exec, String id, START start, FlowNode... parents)
protected	BlockStartNode(FlowExecution exec, String id, FlowNode... parents)
	EnclosingBlocksIterable(GraphLookupView view, FlowNode node)
	FlowEndNode(FlowExecution exec, String id, FlowStartNode start, Result result, FlowNode... parents)
protected	FlowNode(FlowExecution exec, String id, FlowNode... parents)
	ForkNode(FlowExecution storage, String id, FlowNode... parents)	Deprecated.

Constructor parameters in org.jenkinsci.plugins.workflow.graph with type arguments of type FlowNode

Modifier	Constructor	Description
	BlockEndNode(FlowExecution exec, String id, START start, List<FlowNode> parents)
protected	BlockStartNode(FlowExecution exec, String id, List<FlowNode> parents)
protected	FlowNode(FlowExecution exec, String id, List<FlowNode> parents)
	JoinNode(FlowExecution exec, String id, ForkNode forkNode, List<FlowNode> parents)	Deprecated.

Uses of FlowNode in org.jenkinsci.plugins.workflow.graphanalysis

Fields in org.jenkinsci.plugins.workflow.graphanalysis declared as FlowNode

Modifier and Type	Field	Description
protected FlowNode	MemoryFlowChunk.firstNode
protected FlowNode	MemoryFlowChunk.lastNode
protected FlowNode	AbstractFlowScanner.myCurrent
protected FlowNode	AbstractFlowScanner.myNext
protected FlowNode	MemoryFlowChunk.nodeAfter
protected FlowNode	MemoryFlowChunk.nodeBefore

Fields in org.jenkinsci.plugins.workflow.graphanalysis with type parameters of type FlowNode

Modifier and Type	Field	Description
static final Comparator<FlowNode>	FlowScanningUtils.ID_ORDER_COMPARATOR
static final com.google.common.base.Predicate<FlowNode>	FlowScanningUtils.MATCH_BLOCK_START
protected Collection<FlowNode>	AbstractFlowScanner.myBlackList
protected ArrayDeque<FlowNode>	DepthFirstScanner.queue
static final Comparator<FlowNode>	FlowScanningUtils.TIME_ORDER_COMPARATOR	Sorts flownodes putting the one begun last (oldest startTime) at the end, with null times last because likely they represent the newest nodes with a TimingAction not attached yet.
protected HashSet<FlowNode>	DepthFirstScanner.visited

Methods in org.jenkinsci.plugins.workflow.graphanalysis that return FlowNode

Modifier and Type	Method	Description
FlowNode	AbstractFlowScanner.findFirstMatch(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) where there is no denyList
FlowNode	AbstractFlowScanner.findFirstMatch(Collection<FlowNode> heads, Collection<FlowNode> blackListNodes, com.google.common.base.Predicate<FlowNode> matchCondition)	Find the first FlowNode within the iteration order matching a given condition Includes null-checking on arguments to allow directly calling with unchecked inputs (simplifies use).
FlowNode	AbstractFlowScanner.findFirstMatch(FlowExecution exec, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) using FlowExecution.getCurrentHeads() to get heads and no denyList
FlowNode	AbstractFlowScanner.findFirstMatch(FlowNode head, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) where there is a single head and no denyList
FlowNode	LinearScanner.findFirstMatch(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. prefer AbstractFlowScanner.findFirstMatch(FlowNode, Predicate)
FlowNode	LinearScanner.findFirstMatch(Collection<FlowNode> heads, Collection<FlowNode> blackListNodes, com.google.common.base.Predicate<FlowNode> matchCondition)	Find the first FlowNode within the iteration order matching a given condition Includes null-checking on arguments to allow directly calling with unchecked inputs (simplifies use).
FlowNode	LinearScanner.findFirstMatch(FlowExecution exec, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. unsafe to call
FlowNode	ForkScanner.getCurrentParallelStartNode()	Return the node that begins the current parallel head, if we are known to be in a parallel block
FlowNode	FlowChunk.getFirstNode()
FlowNode	MemoryFlowChunk.getFirstNode()
FlowNode	FlowChunk.getLastNode()
FlowNode	MemoryFlowChunk.getLastNode()
FlowNode	FlowChunkWithContext.getNodeAfter()	Return the node after this chunk, or null if it is the end
FlowNode	MemoryFlowChunk.getNodeAfter()
FlowNode	FlowChunkWithContext.getNodeBefore()	Return the node before this chunk, or null if it is the beginning
FlowNode	MemoryFlowChunk.getNodeBefore()
protected FlowNode	LinearBlockHoppingScanner.jumpBlockScan(FlowNode node, Collection<FlowNode> blacklistNodes)	Keeps jumping over blocks until we hit the first node preceding a block
FlowNode	AbstractFlowScanner.next()
protected abstract FlowNode	AbstractFlowScanner.next(FlowNode current, Collection<FlowNode> blackList)	Actual meat of the iteration, get the next node to visit, using and updating state as needed
protected FlowNode	DepthFirstScanner.next(FlowNode current, Collection<FlowNode> blackList)
FlowNode	ForkScanner.next()
protected FlowNode	ForkScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	LinearBlockHoppingScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	LinearScanner.next(FlowNode current, Collection<FlowNode> blackList)

Methods in org.jenkinsci.plugins.workflow.graphanalysis that return types with arguments of type FlowNode

Modifier and Type	Method	Description
List<FlowNode>	AbstractFlowScanner.allNodes(Collection<FlowNode> heads)	Convenience method to get the list all flownodes in the iterator order.
List<FlowNode>	AbstractFlowScanner.allNodes(FlowExecution exec)	Convenience method to get the list of all FlowNodes for the execution, in iterator order.
protected Collection<FlowNode>	AbstractFlowScanner.convertToFastCheckable(Collection<FlowNode> nodeCollection)	Helper: convert stop nodes to a collection that can efficiently be checked for membership, handling null if needed
static Filterator<FlowNode>	FlowScanningUtils.fetchEnclosingBlocks(FlowNode f)	Deprecated.
Filterator<FlowNode>	AbstractFlowScanner.filter(com.google.common.base.Predicate<FlowNode> filterCondition)	Expose a filtered view of this FlowScanner's output.
List<FlowNode>	AbstractFlowScanner.filteredNodes(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.filteredNodes(Collection, Collection, Predicate) with no denyList nodes
List<FlowNode>	AbstractFlowScanner.filteredNodes(Collection<FlowNode> heads, Collection<FlowNode> blackList, com.google.common.base.Predicate<FlowNode> matchCondition)	Return a filtered list of FlowNodes matching a condition, in the order encountered.
List<FlowNode>	AbstractFlowScanner.filteredNodes(FlowExecution exec, com.google.common.base.Predicate<FlowNode> matchPredicate)
List<FlowNode>	AbstractFlowScanner.filteredNodes(FlowNode head, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.filteredNodes(Collection, Collection, Predicate) with a single head and no denyList nodes
List<FlowNode>	LinearScanner.filteredNodes(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. prefer AbstractFlowScanner.filteredNodes(FlowNode, Predicate)
List<FlowNode>	LinearScanner.filteredNodes(Collection<FlowNode> heads, Collection<FlowNode> blackList, com.google.common.base.Predicate<FlowNode> matchCondition)	Return a filtered list of FlowNodes matching a condition, in the order encountered.
static com.google.common.base.Predicate<FlowNode>	FlowScanningUtils.hasActionPredicate(Class<? extends Action> actionClass)	Create a predicate that will match on all FlowNodes having a specific action present
Iterator<FlowNode>	AbstractFlowScanner.iterator()

Methods in org.jenkinsci.plugins.workflow.graphanalysis with parameters of type FlowNode

Modifier and Type	Method	Description
boolean	NodeStepNamePredicate.apply(FlowNode input)
boolean	NodeStepTypePredicate.apply(FlowNode input)
void	SimpleChunkVisitor.atomNode(FlowNode before, FlowNode atomNode, FlowNode after, ForkScanner scan)	Called for a flownode neither start nor end.
void	StandardChunkVisitor.atomNode(FlowNode before, FlowNode atomNode, FlowNode after, ForkScanner scan)	Extend me to do something with nodes inside a chunk
void	SimpleChunkVisitor.chunkEnd(FlowNode endNode, FlowNode afterChunk, ForkScanner scanner)	Called when hitting the end of a chunk.
void	StandardChunkVisitor.chunkEnd(FlowNode endNode, FlowNode afterChunk, ForkScanner scanner)
void	SimpleChunkVisitor.chunkStart(FlowNode startNode, FlowNode beforeBlock, ForkScanner scanner)	Called when hitting the start of a chunk.
void	StandardChunkVisitor.chunkStart(FlowNode startNode, FlowNode beforeBlock, ForkScanner scanner)
static Filterator<FlowNode>	FlowScanningUtils.fetchEnclosingBlocks(FlowNode f)	Deprecated.
List<FlowNode>	AbstractFlowScanner.filteredNodes(FlowNode head, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.filteredNodes(Collection, Collection, Predicate) with a single head and no denyList nodes
FlowNode	AbstractFlowScanner.findFirstMatch(FlowNode head, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) where there is a single head and no denyList
boolean	BlockChunkFinder.isChunkEnd(FlowNode current, FlowNode previous)
boolean	ChunkFinder.isChunkEnd(FlowNode current, FlowNode previous)	Test if the current node is the end of a chunk (inclusive)
boolean	LabelledChunkFinder.isChunkEnd(FlowNode current, FlowNode previous)	End is where the previous node is a chunk start or this is a BlockEndNode whose BlockStartNode has a label action
boolean	BlockChunkFinder.isChunkStart(FlowNode current, FlowNode previous)
boolean	ChunkFinder.isChunkStart(FlowNode current, FlowNode previous)	Test if the current node is the start of a new chunk (inclusive)
boolean	LabelledChunkFinder.isChunkStart(FlowNode current, FlowNode previous)	Start is anywhere with a LabelAction
static boolean	ForkScanner.isParallelEnd(FlowNode f)
static boolean	ForkScanner.isParallelStart(FlowNode f)
protected FlowNode	LinearBlockHoppingScanner.jumpBlockScan(FlowNode node, Collection<FlowNode> blacklistNodes)	Keeps jumping over blocks until we hit the first node preceding a block
protected abstract FlowNode	AbstractFlowScanner.next(FlowNode current, Collection<FlowNode> blackList)	Actual meat of the iteration, get the next node to visit, using and updating state as needed
protected FlowNode	DepthFirstScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	ForkScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	LinearBlockHoppingScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	LinearScanner.next(FlowNode current, Collection<FlowNode> blackList)
void	SimpleChunkVisitor.parallelBranchEnd(FlowNode parallelStartNode, FlowNode branchEndNode, ForkScanner scanner)	Hit the end start of a parallel branch
void	StandardChunkVisitor.parallelBranchEnd(FlowNode parallelStartNode, FlowNode branchEndNode, ForkScanner scanner)
void	SimpleChunkVisitor.parallelBranchStart(FlowNode parallelStartNode, FlowNode branchStartNode, ForkScanner scanner)	Hit the start of a parallel branch
void	StandardChunkVisitor.parallelBranchStart(FlowNode parallelStartNode, FlowNode branchStartNode, ForkScanner scanner)
void	SimpleChunkVisitor.parallelEnd(FlowNode parallelStartNode, FlowNode parallelEndNode, ForkScanner scanner)	Notifies that we've seen the end of a parallel block
void	StandardChunkVisitor.parallelEnd(FlowNode parallelStartNode, FlowNode parallelEndNode, ForkScanner scanner)
void	SimpleChunkVisitor.parallelStart(FlowNode parallelStartNode, FlowNode branchNode, ForkScanner scanner)	Notifies that we've hit the start of a parallel block (the point where it branches out).
void	StandardChunkVisitor.parallelStart(FlowNode parallelStartNode, FlowNode branchNode, ForkScanner scanner)
protected boolean	DepthFirstScanner.possibleParallelStart(FlowNode f)
void	MemoryFlowChunk.setFirstNode(FlowNode firstNode)
void	MemoryFlowChunk.setLastNode(FlowNode lastNode)
void	MemoryFlowChunk.setNodeAfter(FlowNode nodeAfter)
void	MemoryFlowChunk.setNodeBefore(FlowNode nodeBefore)
boolean	AbstractFlowScanner.setup(FlowNode head)	Helper: version of AbstractFlowScanner.setup(Collection, Collection) where we don't have any nodes to denylist and have just a single head
boolean	AbstractFlowScanner.setup(FlowNode head, Collection<FlowNode> blackList)	Helper: version of AbstractFlowScanner.setup(Collection, Collection) where we don't have any nodes to denylist, and have just a single head
protected boolean	DepthFirstScanner.testCandidate(FlowNode f, Collection<FlowNode> blackList)
boolean	FlowNodeVisitor.visit(FlowNode f)	Visit the flow node, and indicate if we should continue analysis

Method parameters in org.jenkinsci.plugins.workflow.graphanalysis with type arguments of type FlowNode

Modifier and Type	Method	Description
List<FlowNode>	AbstractFlowScanner.allNodes(Collection<FlowNode> heads)	Convenience method to get the list all flownodes in the iterator order.
protected Collection<FlowNode>	AbstractFlowScanner.convertToFastCheckable(Collection<FlowNode> nodeCollection)	Helper: convert stop nodes to a collection that can efficiently be checked for membership, handling null if needed
Filterator<FlowNode>	AbstractFlowScanner.filter(com.google.common.base.Predicate<FlowNode> filterCondition)	Expose a filtered view of this FlowScanner's output.
List<FlowNode>	AbstractFlowScanner.filteredNodes(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.filteredNodes(Collection, Collection, Predicate) with no denyList nodes
List<FlowNode>	AbstractFlowScanner.filteredNodes(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.filteredNodes(Collection, Collection, Predicate) with no denyList nodes
List<FlowNode>	AbstractFlowScanner.filteredNodes(Collection<FlowNode> heads, Collection<FlowNode> blackList, com.google.common.base.Predicate<FlowNode> matchCondition)	Return a filtered list of FlowNodes matching a condition, in the order encountered.
List<FlowNode>	AbstractFlowScanner.filteredNodes(Collection<FlowNode> heads, Collection<FlowNode> blackList, com.google.common.base.Predicate<FlowNode> matchCondition)	Return a filtered list of FlowNodes matching a condition, in the order encountered.
List<FlowNode>	AbstractFlowScanner.filteredNodes(FlowExecution exec, com.google.common.base.Predicate<FlowNode> matchPredicate)
List<FlowNode>	AbstractFlowScanner.filteredNodes(FlowNode head, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.filteredNodes(Collection, Collection, Predicate) with a single head and no denyList nodes
List<FlowNode>	LinearScanner.filteredNodes(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. prefer AbstractFlowScanner.filteredNodes(FlowNode, Predicate)
List<FlowNode>	LinearScanner.filteredNodes(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. prefer AbstractFlowScanner.filteredNodes(FlowNode, Predicate)
List<FlowNode>	LinearScanner.filteredNodes(Collection<FlowNode> heads, Collection<FlowNode> blackList, com.google.common.base.Predicate<FlowNode> matchCondition)	Return a filtered list of FlowNodes matching a condition, in the order encountered.
List<FlowNode>	LinearScanner.filteredNodes(Collection<FlowNode> heads, Collection<FlowNode> blackList, com.google.common.base.Predicate<FlowNode> matchCondition)	Return a filtered list of FlowNodes matching a condition, in the order encountered.
FlowNode	AbstractFlowScanner.findFirstMatch(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) where there is no denyList
FlowNode	AbstractFlowScanner.findFirstMatch(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) where there is no denyList
FlowNode	AbstractFlowScanner.findFirstMatch(Collection<FlowNode> heads, Collection<FlowNode> blackListNodes, com.google.common.base.Predicate<FlowNode> matchCondition)	Find the first FlowNode within the iteration order matching a given condition Includes null-checking on arguments to allow directly calling with unchecked inputs (simplifies use).
FlowNode	AbstractFlowScanner.findFirstMatch(Collection<FlowNode> heads, Collection<FlowNode> blackListNodes, com.google.common.base.Predicate<FlowNode> matchCondition)	Find the first FlowNode within the iteration order matching a given condition Includes null-checking on arguments to allow directly calling with unchecked inputs (simplifies use).
FlowNode	AbstractFlowScanner.findFirstMatch(FlowExecution exec, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) using FlowExecution.getCurrentHeads() to get heads and no denyList
FlowNode	AbstractFlowScanner.findFirstMatch(FlowNode head, com.google.common.base.Predicate<FlowNode> matchPredicate)	Syntactic sugar for AbstractFlowScanner.findFirstMatch(Collection, Collection, Predicate) where there is a single head and no denyList
FlowNode	LinearScanner.findFirstMatch(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. prefer AbstractFlowScanner.findFirstMatch(FlowNode, Predicate)
FlowNode	LinearScanner.findFirstMatch(Collection<FlowNode> heads, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. prefer AbstractFlowScanner.findFirstMatch(FlowNode, Predicate)
FlowNode	LinearScanner.findFirstMatch(Collection<FlowNode> heads, Collection<FlowNode> blackListNodes, com.google.common.base.Predicate<FlowNode> matchCondition)	Find the first FlowNode within the iteration order matching a given condition Includes null-checking on arguments to allow directly calling with unchecked inputs (simplifies use).
FlowNode	LinearScanner.findFirstMatch(Collection<FlowNode> heads, Collection<FlowNode> blackListNodes, com.google.common.base.Predicate<FlowNode> matchCondition)	Find the first FlowNode within the iteration order matching a given condition Includes null-checking on arguments to allow directly calling with unchecked inputs (simplifies use).
FlowNode	LinearScanner.findFirstMatch(FlowExecution exec, com.google.common.base.Predicate<FlowNode> matchPredicate)	Deprecated. unsafe to call
protected FlowNode	LinearBlockHoppingScanner.jumpBlockScan(FlowNode node, Collection<FlowNode> blacklistNodes)	Keeps jumping over blocks until we hit the first node preceding a block
protected abstract FlowNode	AbstractFlowScanner.next(FlowNode current, Collection<FlowNode> blackList)	Actual meat of the iteration, get the next node to visit, using and updating state as needed
protected FlowNode	DepthFirstScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	ForkScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	LinearBlockHoppingScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected FlowNode	LinearScanner.next(FlowNode current, Collection<FlowNode> blackList)
protected abstract void	AbstractFlowScanner.setHeads(Collection<FlowNode> filteredHeads)	Set up to begin flow scanning using the filteredHeads as starting points This method makes several assumptions: - AbstractFlowScanner.reset() has already been invoked to reset state - filteredHeads has already had any points in AbstractFlowScanner.myBlackList removed - none of the filteredHeads are null
protected void	DepthFirstScanner.setHeads(Collection<FlowNode> heads)
protected void	ForkScanner.setHeads(Collection<FlowNode> heads)
protected void	LinearBlockHoppingScanner.setHeads(Collection<FlowNode> heads)
protected void	LinearScanner.setHeads(Collection<FlowNode> heads)	Set up to begin flow scanning using the filteredHeads as starting points This method makes several assumptions: - AbstractFlowScanner.reset() has already been invoked to reset state - filteredHeads has already had any points in AbstractFlowScanner.myBlackList removed - none of the filteredHeads are null
static void	ForkScanner.setParallelStartPredicate(com.google.common.base.Predicate<FlowNode> pred)	Deprecated.
boolean	AbstractFlowScanner.setup(Collection<FlowNode> heads)	Helper: version of AbstractFlowScanner.setup(Collection, Collection) where we don't have any nodes to denylist
boolean	AbstractFlowScanner.setup(Collection<FlowNode> heads, Collection<FlowNode> blackList)	Set up for iteration/analysis on a graph of nodes, initializing the internal state Includes null-checking on arguments to allow directly calling with unchecked inputs (simplifies use).
boolean	AbstractFlowScanner.setup(FlowNode head, Collection<FlowNode> blackList)	Helper: version of AbstractFlowScanner.setup(Collection, Collection) where we don't have any nodes to denylist, and have just a single head
boolean	LinearBlockHoppingScanner.setup(Collection<FlowNode> heads, Collection<FlowNode> blackList)
boolean	LinearScanner.setup(Collection<FlowNode> heads)	Deprecated. prefer AbstractFlowScanner.setup(FlowNode)
boolean	LinearScanner.setup(Collection<FlowNode> heads, Collection<FlowNode> blackList)	Deprecated. prefer AbstractFlowScanner.setup(FlowNode, Collection)
protected boolean	DepthFirstScanner.testCandidate(FlowNode f, Collection<FlowNode> blackList)
void	AbstractFlowScanner.visitAll(Collection<FlowNode> heads, Collection<FlowNode> blackList, FlowNodeVisitor visitor)	Given a FlowNodeVisitor, invoke FlowNodeVisitor.visit(FlowNode) on each node and halt early if it returns false.
void	AbstractFlowScanner.visitAll(Collection<FlowNode> heads, FlowNodeVisitor visitor)	Syntactic sugar for AbstractFlowScanner.visitAll(Collection, Collection, FlowNodeVisitor) where we don't denylist any nodes
void	LinearScanner.visitAll(Collection<FlowNode> heads, Collection<FlowNode> blackList, FlowNodeVisitor visitor)	Given a FlowNodeVisitor, invoke FlowNodeVisitor.visit(FlowNode) on each node and halt early if it returns false.
void	LinearScanner.visitAll(Collection<FlowNode> heads, FlowNodeVisitor visitor)	Syntactic sugar for AbstractFlowScanner.visitAll(Collection, Collection, FlowNodeVisitor) where we don't denylist any nodes
static void	ForkScanner.visitSimpleChunks(Collection<FlowNode> heads, Collection<FlowNode> blacklist, SimpleChunkVisitor visitor, ChunkFinder finder)
static void	ForkScanner.visitSimpleChunks(Collection<FlowNode> heads, SimpleChunkVisitor visitor, ChunkFinder finder)

Constructors in org.jenkinsci.plugins.workflow.graphanalysis with parameters of type FlowNode

Modifier	Constructor	Description
	MemoryFlowChunk(FlowNode before, FlowNode firstNode, FlowNode lastNode, FlowNode nodeAfter)
	ParallelMemoryFlowChunk(FlowNode firstNode, FlowNode lastNode)
	ParallelMemoryFlowChunk(FlowNode nodeBefore, FlowNode firstNode, FlowNode lastNode, FlowNode nodeAfter)

Constructor parameters in org.jenkinsci.plugins.workflow.graphanalysis with type arguments of type FlowNode

Modifier	Constructor	Description
	ForkScanner(Collection<FlowNode> heads)
	ForkScanner(Collection<FlowNode> heads, Collection<FlowNode> blackList)

Uses of FlowNode in org.jenkinsci.plugins.workflow.log

Methods in org.jenkinsci.plugins.workflow.log that return types with arguments of type FlowNode

Modifier and Type	Method	Description
AnnotatedLargeText<FlowNode>	BrokenLogStorage.stepLog(FlowNode node, boolean complete)
AnnotatedLargeText<FlowNode>	FileLogStorage.stepLog(FlowNode node, boolean complete)
AnnotatedLargeText<FlowNode>	LogStorage.stepLog(FlowNode node, boolean complete)	Provides an alternate way of retrieving output from a build.

Methods in org.jenkinsci.plugins.workflow.log with parameters of type FlowNode

Modifier and Type	Method	Description
TaskListener	BrokenLogStorage.nodeListener(FlowNode node)
TaskListener	FileLogStorage.nodeListener(FlowNode node)
TaskListener	LogStorage.nodeListener(FlowNode node)	Provides an alternate way of emitting output from a node (such as a step).
AnnotatedLargeText<FlowNode>	BrokenLogStorage.stepLog(FlowNode node, boolean complete)
AnnotatedLargeText<FlowNode>	FileLogStorage.stepLog(FlowNode node, boolean complete)
AnnotatedLargeText<FlowNode>	LogStorage.stepLog(FlowNode node, boolean complete)	Provides an alternate way of retrieving output from a build.