Package com.vladsch.flexmark.util.visitor

Class AstActionHandler<C extends AstActionHandler<C,N,A,H>,N,A extends AstAction<N>,H extends AstHandler<N,A>>

java.lang.Object

com.vladsch.flexmark.util.visitor.AstActionHandler<C,N,A,H>

Type Parameters:

C - subclass of this class to have functions returning this to have the correct type

N - base node type, this class does not care but in specific handlers it should be a common supertype for all nodes

A - action type, subclasses of AstAction and AstHandler provide actual functionality

H - handler to invoke the functionality during AST traversal for specific node

public abstract class AstActionHandler<C extends AstActionHandler<C,N,A,H>,N,A extends AstAction<N>,H extends AstHandler<N,A>>
extends Object

Intended to be completed by subclasses for specific node types and node actions

Constructor Summary

Constructors

Constructor	Description
AstActionHandler(@NotNull AstNode<N> astAdapter)

Method Summary

Modifier and Type	Method	Description
protected C	addActionHandler(H handler)
protected C	addActionHandlers(@NotNull H[]... handlers)
A	getAction(@NotNull Class<?> nodeClass)
A	getAction(N node)
protected H	getHandler(@NotNull Class<?> nodeClass)
protected H	getHandler(N node)
@NotNull Set<Class<? extends N>>	getNodeClasses()
protected void	processChildren(N node, @NotNull BiConsumer<N,A> processor)
protected void	processNode(N node, boolean withChildren, @NotNull BiConsumer<N,A> processor)	Node processing called for every node being processed
protected <R> R	processNodeOnly(N node, R defaultValue, @NotNull BiFunction<N,A,R> processor)	Process the node and return value from the processor

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AstActionHandler

public AstActionHandler(@NotNull
                        @NotNull AstNode<N> astAdapter)

Method Detail

addActionHandlers

@SafeVarargs
@NotNull
protected final C addActionHandlers(@NotNull
                                    @NotNull H[]... handlers)

addActionHandler

@NotNull
protected C addActionHandler(@NotNull
                             H handler)

getAction

@Nullable
public A getAction(@NotNull
                   N node)

getAction

@Nullable
public A getAction(@NotNull
                   @NotNull Class<?> nodeClass)

getHandler

@Nullable
protected H getHandler(@NotNull
                       N node)

getHandler

@Nullable
protected H getHandler(@NotNull
                       @NotNull Class<?> nodeClass)

getNodeClasses

@NotNull
public @NotNull Set<Class<? extends N>> getNodeClasses()

processNode

protected void processNode(@NotNull
                           N node,
                           boolean withChildren,
                           @NotNull
                           @NotNull BiConsumer<N,A> processor)

Node processing called for every node being processed

Override this to add customizations to standard processing callback.

Parameters:

node - node being processed

withChildren - whether to process child nodes if there is no handler for the node type

processor - processor to invoke to perform the processing, BiConsumer taking N node, and A action

processChildren

protected final void processChildren(@NotNull
                                     N node,
                                     @NotNull
                                     @NotNull BiConsumer<N,A> processor)

processNodeOnly

protected final <R> R processNodeOnly(@NotNull
                                      N node,
                                      R defaultValue,
                                      @NotNull
                                      @NotNull BiFunction<N,A,R> processor)

Process the node and return value from the processor

Type Parameters:

R - type of result returned by processor

Parameters:

node - node to process

defaultValue - default value if no handler is defined for the node

processor - processor to pass the node and handler for processing

Returns:

result or defaultValue