Package io.github.douira.glsl_transformer.ast.query

Class Root

java.lang.Object
io.github.douira.glsl_transformer.ast.query.Root
Direct Known Subclasses:
EmptyRoot
public class Root extends Object
Each AST has a root referenced by all its members. This class manages the indexes of the tree and is updated each time a node is added or removed from the tree. It also contains methods for indexing nodes for building a tree and for performing replacement operations on the tree using the stored indexes.

  • Field Details

    • nodeIndex

      public final NodeIndex nodeIndex
      The node index is used to query nodes by their type. There are various available node index implementations that provide different trade-offs between performance, memory consumption and query capabilities.

    • identifierIndex

      public final IdentifierIndex<?> identifierIndex
      The identifier index is used to query identifiers by their name or prefixes on their name. There are various available identifier index implementations that provide different trade-offs between performance, memory consumption and query capabilities.

  • Constructor Details

    • Root

      public Root(NodeIndex nodeIndex, IdentifierIndex<?> identifierIndex)
      Constructs a new root with the given node and identifier indexes.
      Parameters:
      nodeIndex - The node index
      identifierIndex - The identifier index

    • Root

      public Root()
      Constructs a new root with the default node and identifier indexes which have the least amount of functionality but are also the most efficient.

  • Method Details

    • getActiveBuildRoot

      public static Root getActiveBuildRoot()
      Returns the currently active build root. When nodes are constructed within a build session, this method returns the root of the build session. Nodes can't be constructed with children if they have no root since the children must be registered with the root.
      Returns:
      the currently active build root

    • withActiveBuildRoot

      protected static final <R> R withActiveBuildRoot(Root instance, Function<Root,R> rootConsumer)
      Runs the given consumer with the given root as the active build root.
      Type Parameters:
      R - The return type of the consumer
      Parameters:
      instance - The root to run the consumer with
      rootConsumer - The consumer to run
      Returns:
      The return value of the consumer

    • indexNodes

      public static <NodeType extends ASTNode> NodeType indexNodes(Root instance, Supplier<NodeType> builder)
      Runs the given builder supplier with the given root as the active build root and then registers the returned node with the root. This is necessary since the node will have the correct root but will not be registered until it is either manually registered as it is being done here or added as a child to another node with the root.
      Type Parameters:
      NodeType - The type of the node to build
      Parameters:
      instance - The root to run the builder with
      builder - The builder to run
      Returns:
      The built and registered node

    • indexNodes

      public static <NodeType extends ASTNode> NodeType indexNodes(Supplier<NodeType> builder)
      Runs the given builder supplier with a new root as the active build root.
      Type Parameters:
      NodeType - The type of the node to build
      Parameters:
      builder - The builder to run
      Returns:
      The built and registered node

    • indexNodes

      public static <NodeType extends ASTNode> NodeType indexNodes(ASTNode parentTreeMember, Supplier<NodeType> builder)
      Runs the given builder supplier with the same root as a given tree node as the active build root.
      Type Parameters:
      NodeType - The type of the node to build
      Parameters:
      parentTreeMember - The tree member to get the root from
      builder - The builder to run
      Returns:
      The built and registered node

    • indexBuildSession

      public static void indexBuildSession(Root instance, Runnable session)
      Runs a given runnable with the given root as the active build root. This is used for constructing nodes with children without registering the constructed root node with the root or for registering it manually.
      Parameters:
      instance - The root to use as the active build root
      session - The runnable to run

    • indexBuildSession

      public static void indexBuildSession(Runnable session)
      Runs the given runnable with a new root as the active build root.
      Parameters:
      session - The runnable to run

    • indexBuildSession

      public static void indexBuildSession(ASTNode treeMember, Runnable session)
      Runs the given runnable with the same root as a given tree node as the active build root.
      Parameters:
      treeMember - The tree member to get the root from
      session - The runnable to run

    • indexSeparateTrees

      public static <NodeType extends ASTNode> void indexSeparateTrees(Root instance, Consumer<Passthrough<NodeType>> registererConsumer)
      Runs the given consumer of a registration pass-through function with the given root as the active build root. The consumer receives a pass-through function that takes a constructed node and registers it with the root. This is helpful for constructing trees manually and registering them inline.
      Type Parameters:
      NodeType - The type of the nodes to register
      Parameters:
      instance - the root to register the nodes with
      registererConsumer - The consumer to run

    • indexSeparateTrees

      public static <NodeType extends ASTNode> void indexSeparateTrees(Consumer<Passthrough<NodeType>> registerer)
      Runs the given consumer of a registration pass-through function with a new root as the active build root.
      Type Parameters:
      NodeType - The type of the nodes to register
      Parameters:
      registerer - The consumer to run

    • indexSeparateTrees

      public static <NodeType extends ASTNode> void indexSeparateTrees(ASTNode treeMember, Consumer<Passthrough<NodeType>> registerer)
      Runs the given consumer of a registration pass-through function with the same root as a given tree node as the active build root.
      Type Parameters:
      NodeType - The type of the nodes to register
      Parameters:
      treeMember - The tree member to get the root from
      registerer - The consumer to run

    • registerNode

      public void registerNode(ASTNode node)
      Registers the given node with this root.
      Parameters:
      node - The node to register

    • unregisterNode

      public void unregisterNode(ASTNode node)
      Unregisters the given node from this root.
      Parameters:
      node - The node to unregister

    • unregisterIdentifierRename

      public void unregisterIdentifierRename(Identifier identifier)

    • registerIdentifierRename

      public void registerIdentifierRename(Identifier identifier)

    • rename

      public boolean rename(String oldName, String newName)
      Renames all identifiers with the given old name to the given new name.
      Parameters:
      oldName - The old name
      newName - The new name
      Returns:
      Whether anything was renamed

    • process

      public <T extends ASTNode> boolean process(Stream<? extends T> targets, Consumer<? super T> replacer)
      Processes all target nodes from the given stream with the given consumer. This method ensures there is no concurrent modification of the node index by collecting the stream into a shared list.
      Type Parameters:
      T - The type of the target nodes
      Parameters:
      targets - The stream of target nodes to process
      replacer - The consumer to process the target nodes with
      Returns:
      Whether anything was processed

    • process

      public boolean process(String name, Consumer<Identifier> replacer)
      Processes all identifiers with the given name with the given consumer.
      Parameters:
      name - The name of the identifiers to process
      replacer - The consumer to process the identifiers with
      Returns:
      Whether anything was processed

    • replaceReferenceExpressions

      public void replaceReferenceExpressions(ASTParser t, String name, String expression)
      Replaces all reference expressions containing identifiers with the given name with the given replacement expression. Identifiers that are not part of a reference expression are not replaced since an expression would be impossible as a replacement.
      Parameters:
      t - The AST transformer
      name - The name of the identifiers to target
      expression - The content of the replacement expression

    • replaceReferenceExpressionsReport

      public boolean replaceReferenceExpressionsReport(ASTParser t, String name, String expression)
      Replaces all reference expressions containing identifiers with the given name with the given replacement expression. Identifiers that are not part of a reference expression are not replaced since an expression would be impossible as a replacement.
      Parameters:
      t - The AST transformer
      name - The name of the identifiers to target
      expression - The content of the replacement expression
      Returns:
      Whether any replacements were made

    • replaceReferenceExpressions

      public void replaceReferenceExpressions(ASTParser t, Stream<Identifier> targets, String expression)
      Replaces all reference expressions containing the given identifiers from the given stream with the given replacement expression.
      Parameters:
      t - The AST transformer
      targets - The stream of identifiers to target
      expression - The content of the replacement expression

    • replaceReferenceExpressionsReport

      public boolean replaceReferenceExpressionsReport(ASTParser t, Stream<Identifier> targets, String expression)
      Replaces all reference expressions containing the given identifiers from the given stream with the given replacement expression.
      Parameters:
      t - The AST transformer
      targets - The stream of identifiers to target
      expression - The content of the replacement expression
      Returns:
      Whether any replacements were made

    • replaceExpressions

      public boolean replaceExpressions(ASTParser t, Stream<? extends Expression> targets, String expression)
      Replaces all expressions from the given stream with the given replacement expression.
      Parameters:
      t - The AST transformer
      targets - The stream of expressions to target
      expression - The content of the replacement expression
      Returns:
      Whether any replacements were made

    • replaceExpressionsConcurrent

      public static boolean replaceExpressionsConcurrent(ASTParser t, List<? extends Expression> targets, String expression)
      Replaces all expressions from the given list with the given replacement expression but without storing the targets in an intermediary list under the assumption that this list will not be modified by the replacement.
      Parameters:
      t - The AST transformer
      targets - The list of expressions to target
      expression - The content of the replacement expression
      Returns:
      Whether any replacements were made

    • processMatches

      public <T extends ASTNode> boolean processMatches(ASTParser t, Stream<? extends ASTNode> matchTargetChildren, Matcher<T> matcher, Consumer<? super T> replacer)
      Processes all matches of nodes from the given stream matched with the given matcher.
      Type Parameters:
      T - The type of the matched nodes
      Parameters:
      t - The AST transformer
      matchTargetChildren - The stream of nodes to match
      matcher - The matcher to match the nodes with
      replacer - The consumer to process the matched nodes with
      Returns:
      Whether anything was processed

    • processMatches

      public <T extends ASTNode> boolean processMatches(ASTParser t, HintedMatcher<T> hintedMatcher, Consumer<? super T> replacer)
      Processes all matches of nodes in the tree that match the given hinted matcher. The hint is used to identify the nodes to match.
      Type Parameters:
      T - The type of the matched nodes
      Parameters:
      t - The AST transformer
      hintedMatcher - The matcher to match the nodes with
      replacer - The consumer to process the matched nodes with
      Returns:
      Whether anything was processed

    • replaceExpressionMatches

      public <T extends Expression> boolean replaceExpressionMatches(ASTParser t, Stream<? extends ASTNode> matchTargetChildren, Matcher<T> matcher, String expression)
      Replaces expressions from the given stream that match the given matcher with new expressions created from the given string.
      Type Parameters:
      T - The type of the matched expression nodes
      Parameters:
      t - The AST transformer
      matchTargetChildren - The stream of nodes to match
      matcher - The matcher to match the nodes with
      expression - The content of the replacement expression
      Returns:
      Whether anything was processed

    • replaceExpressionMatches

      public <T extends Expression> boolean replaceExpressionMatches(ASTParser t, HintedMatcher<T> hintedMatcher, String expression)
      Replaces expressions all matches of expression nodes in the tree that match the given hinted matcher with new expressions created from the given string.
      Type Parameters:
      T - The type of the matched expression nodes
      Parameters:
      t - The AST transformer
      hintedMatcher - The matcher to match the nodes with
      expression - The content of the replacement expression
      Returns:
      Whether anything was processed