LocationPathPattern
Date: 2016-07-03

com.icl.saxon.pattern

## Class LocationPathPattern

- java.lang.Object
- - com.icl.saxon.pattern.Pattern
  - - com.icl.saxon.pattern.LocationPathPattern

-     public final class LocationPathPattern
      extends Pattern

  A LocationPathPattern represents a path, e.g. of the form A/B/C... The components are represented as a linked list, each component pointing to its predecessor

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `Pattern` | `ancestorPattern`
    `protected Expression` | `equivalentExpr`
    `protected Expression[]` | `filters`
    `protected boolean` | `firstElementPattern`
    `protected boolean` | `lastElementPattern`
    `NodeTest` | `nodeTest`
    `protected int` | `numberOfFilters`
    `Pattern` | `parentPattern`
    `protected boolean` | `specialFilter`

    - ### Fields inherited from class com.icl.saxon.pattern.Pattern

      `originalText, staticContext`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `LocationPathPattern()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addFilter(Expression filter)` Add a filter to the pattern (while under construction)
    `int` | `getFingerprint()` Determine the fingerprint of nodes to which this pattern applies.
    `short` | `getNodeType()` Determine the types of nodes to which this pattern applies.
    `boolean` | `isRelative()` Determine if the pattern uses positional filters
    `boolean` | `matches(NodeInfo node, Context context)` Determine whether this Pattern matches the given Node
    `boolean` | `matchesX(NodeInfo node, Context context)` Determine whether the pattern matches a given node.
    `Pattern` | `simplify()` Simplify the pattern: perform any context-independent optimisations

    - ### Methods inherited from class com.icl.saxon.pattern.Pattern

      `getDefaultPriority, getLineNumber, getStaticContext, getSystemId, make, setOriginalText, setStaticContext, toString`

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

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

- - ### Field Detail

    - #### parentPattern

          public Pattern parentPattern

    - #### ancestorPattern

          public Pattern ancestorPattern

    - #### nodeTest

          public NodeTest nodeTest

    - #### filters

          protected Expression[] filters

    - #### numberOfFilters

          protected int numberOfFilters

    - #### equivalentExpr

          protected Expression equivalentExpr

    - #### firstElementPattern

          protected boolean firstElementPattern

    - #### lastElementPattern

          protected boolean lastElementPattern

    - #### specialFilter

          protected boolean specialFilter

  - ### Constructor Detail

    - #### LocationPathPattern

          public LocationPathPattern()

  - ### Method Detail

    - #### addFilter

          public void addFilter(Expression filter)

      Add a filter to the pattern (while under construction)
      Parameters:
        `filter` - The predicate (a boolean expression or numeric expression) to be added

    - #### simplify

          public Pattern simplify()
                           throws XPathException

      Simplify the pattern: perform any context-independent optimisations
      Overrides:
        `simplify` in class `Pattern`
      Returns:
        the optimised Pattern
      Throws:
        `XPathException`

    - #### matchesX

          public boolean matchesX(NodeInfo node,
                         Context context)
                           throws XPathException

      Determine whether the pattern matches a given node.
      Parameters:
        `node` - the node to be tested
      Returns:
        true if the pattern matches, else false
      Throws:
        `XPathException`

    - #### matches

          public boolean matches(NodeInfo node,
                        Context context)
                          throws XPathException

      Description copied from class: `Pattern`
      Determine whether this Pattern matches the given Node
      Specified by:
        `matches` in class `Pattern`
      Parameters:
        `node` - The NodeInfo representing the Element or other node to be tested against the Pattern
        `context` - The context in which the match is to take place. Only relevant if the pattern uses variables.
      Returns:
        true if the node matches the Pattern, false otherwise
      Throws:
        `XPathException`

    - #### getNodeType

          public short getNodeType()

      Determine the types of nodes to which this pattern applies. Used for optimisation. For patterns that match nodes of several types, return Node.NODE
      Overrides:
        `getNodeType` in class `Pattern`
      Returns:
        the type of node matched by this pattern. e.g. Node.ELEMENT or Node.TEXT

    - #### getFingerprint

          public int getFingerprint()

      Determine the fingerprint of nodes to which this pattern applies. Used for optimisation.
      Overrides:
        `getFingerprint` in class `Pattern`
      Returns:
        the fingerprint of nodes matched by this pattern.

    - #### isRelative

          public boolean isRelative()
                             throws XPathException

      Determine if the pattern uses positional filters
      Returns:
        true if there is a numeric filter in the pattern, or one that uses the position() or last() functions
      Throws:
        `XPathException`