## 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
`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
`LocationPathPattern()`

Method Summary
`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
    `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
    `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
    `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
    `XPathException`