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
Direct Known Subclasses:
AttributeProviderAdapter, LinkResolverAdapter, NodeVisitor

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
  • Field Details

    • customHandlersMap

      @NotNull private final @NotNull Map<Class<? extends N>,H extends AstHandler<N,A>> customHandlersMap
    • astAdapter

      @NotNull private final @NotNull AstNode<N> astAdapter
  • Constructor Details

    • AstActionHandler

      public AstActionHandler(@NotNull @NotNull AstNode<N> astAdapter)
  • Method Details

    • addActionHandlers

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

      @NotNull protected C addActionHandler(@NotNull H handler)
    • getAction

      @Nullable private A getAction(@Nullable 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