org.apache.xpath

## Class XPathVisitor

- java.lang.Object
- - org.apache.xpath.XPathVisitor

- Direct Known Subclasses:
    AbsPathChecker, ExpressionVisitor, HasPositionalPredChecker, VarNameCollector, XSLTVisitor

      public class XPathVisitor
      extends java.lang.Object

  A derivation from this class can be passed to a class that implements the XPathVisitable interface, to have the appropriate method called for each component of the XPath. Aside from possible other uses, the main intention is to provide a reasonable means to perform expression rewriting.

  Each method has the form `boolean visitComponentType(ExpressionOwner owner, ComponentType compType)`. The ExpressionOwner argument is the owner of the component, and can be used to reset the expression for rewriting. If a method returns false, the sub hierarchy will not be traversed.

  This class is meant to be a base class that will be derived by concrete classes, and doesn't much except return true for each method.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `XPathVisitor()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `visitBinaryOperation(ExpressionOwner owner, Operation op)` Visit a binary operation.
    `boolean` | `visitFunction(ExpressionOwner owner, Function func)` Visit a function.
    `boolean` | `visitLocationPath(ExpressionOwner owner, LocPathIterator path)` Visit a LocationPath.
    `boolean` | `visitMatchPattern(ExpressionOwner owner, StepPattern pattern)` Visit a match pattern.
    `boolean` | `visitNumberLiteral(ExpressionOwner owner, XNumber num)` Visit a number literal.
    `boolean` | `visitPredicate(ExpressionOwner owner, Expression pred)` Visit a predicate within a location path.
    `boolean` | `visitStep(ExpressionOwner owner, NodeTest step)` Visit a step within a location path.
    `boolean` | `visitStringLiteral(ExpressionOwner owner, XString str)` Visit a string literal.
    `boolean` | `visitUnaryOperation(ExpressionOwner owner, UnaryOperation op)` Visit a unary operation.
    `boolean` | `visitUnionPath(ExpressionOwner owner, UnionPathIterator path)` Visit a UnionPath.
    `boolean` | `visitUnionPattern(ExpressionOwner owner, UnionPattern pattern)` Visit a union pattern.
    `boolean` | `visitVariableRef(ExpressionOwner owner, Variable var)` Visit a variable reference.

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### XPathVisitor

          public XPathVisitor()

  - ### Method Detail

    - #### visitLocationPath

          public boolean visitLocationPath(ExpressionOwner owner,
                                  LocPathIterator path)

      Visit a LocationPath.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `path` - The LocationPath object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitUnionPath

          public boolean visitUnionPath(ExpressionOwner owner,
                               UnionPathIterator path)

      Visit a UnionPath.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `path` - The UnionPath object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitStep

          public boolean visitStep(ExpressionOwner owner,
                          NodeTest step)

      Visit a step within a location path.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `step` - The Step object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitPredicate

          public boolean visitPredicate(ExpressionOwner owner,
                               Expression pred)

      Visit a predicate within a location path. Note that there isn't a proper unique component for predicates, and that the expression will be called also for whatever type Expression is.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `pred` - The predicate object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitBinaryOperation

          public boolean visitBinaryOperation(ExpressionOwner owner,
                                     Operation op)

      Visit a binary operation.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `op` - The operation object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitUnaryOperation

          public boolean visitUnaryOperation(ExpressionOwner owner,
                                    UnaryOperation op)

      Visit a unary operation.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `op` - The operation object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitVariableRef

          public boolean visitVariableRef(ExpressionOwner owner,
                                 Variable var)

      Visit a variable reference.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `var` - The variable reference object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitFunction

          public boolean visitFunction(ExpressionOwner owner,
                              Function func)

      Visit a function.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `func` - The function reference object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitMatchPattern

          public boolean visitMatchPattern(ExpressionOwner owner,
                                  StepPattern pattern)

      Visit a match pattern.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `pattern` - The match pattern object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitUnionPattern

          public boolean visitUnionPattern(ExpressionOwner owner,
                                  UnionPattern pattern)

      Visit a union pattern.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `pattern` - The union pattern object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitStringLiteral

          public boolean visitStringLiteral(ExpressionOwner owner,
                                   XString str)

      Visit a string literal.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `str` - The string literal object.
      Returns:
        true if the sub expressions should be traversed.

    - #### visitNumberLiteral

          public boolean visitNumberLiteral(ExpressionOwner owner,
                                   XNumber num)

      Visit a number literal.
      Parameters:
        `owner` - The owner of the expression, to which the expression can be reset if rewriting takes place.
        `num` - The number literal object.
      Returns:
        true if the sub expressions should be traversed.

Copyright © 2014 Apache XML Project. All Rights Reserved.