## net.sf.saxon.pattern
Class UnionPattern

    java.lang.Object
      net.sf.saxon.pattern.Pattern
          net.sf.saxon.pattern.UnionPattern

All Implemented Interfaces:
  java.io.Serializable, javax.xml.transform.SourceLocator, Container, PatternFinder

    public class UnionPattern

extends Pattern

A pattern formed as the union (or) of two other patterns

See Also:
  Serialized Form

Field Summary
`protected Pattern` `p1`
`protected Pattern` `p2`

Constructor Summary
`UnionPattern(Pattern p1, Pattern p2)` Constructor

Method Summary
`int` `allocateSlots(StaticContext env, SlotManager slotManager, int nextFree)` Allocate slots to any variables used within the pattern
`Pattern` `analyze(ExpressionVisitor visitor, ItemType contextItemType)` Type-check the pattern.
`boolean` `equals(java.lang.Object other)` Determine whether this pattern is the same as another pattern
`void` `gatherComponentPatterns(java.util.Set set)` Gather the component (non-union) patterns of this union pattern
`int` `getDependencies()` Get the dependencies of the pattern.
`Pattern` `getLHS()` Get the LHS of the union
`int` `getNodeKind()` Determine the types of nodes to which this pattern applies.
`NodeTest` `getNodeTest()` Get a NodeTest that all the nodes matching this pattern must satisfy
`Pattern` `getRHS()` Get the RHS of the union
`int` `hashCode()` Hashcode supporting equals()
`java.util.Iterator` `iterateSubExpressions()` Iterate over the subexpressions within this pattern
`boolean` `matches(NodeInfo e, XPathContext context)` Determine if the supplied node matches the pattern
`void` `setExecutable(Executable executable)` Set the executable containing this pattern
`void` `setLineNumber(int lineNumber)` Override method to set the system ID, so it's set on both halves
`void` `setOriginalText(java.lang.String pattern)` Set the original text
`void` `setSystemId(java.lang.String systemId)` Override method to set the system ID, so it's set on both halves
`Pattern` `simplify(ExpressionVisitor visitor)` Simplify the pattern: perform any context-independent optimisations

Methods inherited from class net.sf.saxon.pattern.Pattern
`getColumnNumber, getDefaultPriority, getExecutable, getFingerprint, getHostLanguage, getLineNumber, getLocationProvider, getPublicId, getSystemId, internalMatches, make, makeSearchExpression, promote, replaceSubExpression, selectNodes, toString`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### p1

    protected Pattern p1

### p2

    protected Pattern p2

Constructor Detail

### UnionPattern

    public UnionPattern(Pattern p1,
                        Pattern p2)

  Constructor

  Parameters:
    `p1` - the left-hand operand
    `p2` - the right-hand operand

Method Detail

### setExecutable

    public void setExecutable(Executable executable)

  Set the executable containing this pattern

  Overrides:
    `setExecutable` in class `Pattern`
  Parameters:
    `executable` - the executable

### simplify

    public Pattern simplify(ExpressionVisitor visitor)
                     throws XPathException

  Simplify the pattern: perform any context-independent optimisations

  Overrides:
    `simplify` in class `Pattern`
  Parameters:
    `visitor` - an expression visitor
  Returns:
    the optimised Pattern
  Throws:
    `XPathException`

### analyze

    public Pattern analyze(ExpressionVisitor visitor,
                           ItemType contextItemType)
                    throws XPathException

  Type-check the pattern. This is only needed for patterns that contain variable references or function calls.

  Overrides:
    `analyze` in class `Pattern`
  Parameters:
    `visitor` - the expression visitor
    `contextItemType` - the type of the context item, if known, at the point where the pattern is defined
  Returns:
    the optimised Pattern
  Throws:
    `XPathException`

### setOriginalText

    public void setOriginalText(java.lang.String pattern)

  Set the original text

  Overrides:
    `setOriginalText` in class `Pattern`
  Parameters:
    `pattern` - the original text of the pattern

### allocateSlots

    public int allocateSlots(StaticContext env,
                             SlotManager slotManager,
                             int nextFree)

  Allocate slots to any variables used within the pattern

  Overrides:
    `allocateSlots` in class `Pattern`
  Parameters:
    `env` - the static context in the XSLT stylesheet
    `slotManager` -
    `nextFree` - the next slot that is free to be allocated @return the next slot that is free to be allocated

### gatherComponentPatterns

    public void gatherComponentPatterns(java.util.Set set)

  Gather the component (non-union) patterns of this union pattern

  Parameters:
    `set` - the set into which the components will be added

### matches

    public boolean matches(NodeInfo e,
                           XPathContext context)
                    throws XPathException

  Determine if the supplied node matches the pattern

  Specified by:
    `matches` in class `Pattern`
  Parameters:
    `e` - the node to be compared
    `context` - The dynamic context. Only relevant if the pattern uses variables, or contains calls on functions such as document() or key().
  Returns:
    true if the node matches either of the operand patterns
  Throws:
    `XPathException`

### getNodeKind

    public int getNodeKind()

  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:
    `getNodeKind` in class `Pattern`
  Returns:
    the type of node matched by this pattern. e.g. Node.ELEMENT or Node.TEXT

### getNodeTest

    public NodeTest getNodeTest()

  Get a NodeTest that all the nodes matching this pattern must satisfy

  Specified by:
    `getNodeTest` in class `Pattern`
  Returns:
    a NodeTest, as specific as possible, which all the matching nodes satisfy

### getDependencies

    public int getDependencies()

  Get the dependencies of the pattern. The only possible dependency for a pattern is on local variables. This is analyzed in those patterns where local variables may appear.

  Overrides:
    `getDependencies` in class `Pattern`
  Returns:
    the dependencies, as a bit-significant mask

### iterateSubExpressions

    public java.util.Iterator iterateSubExpressions()

  Iterate over the subexpressions within this pattern

  Overrides:
    `iterateSubExpressions` in class `Pattern`
  Returns:
    an iterator over the subexpressions.

### getLHS

    public Pattern getLHS()

  Get the LHS of the union

  Returns:
    the first operand of the union

### getRHS

    public Pattern getRHS()

  Get the RHS of the union

  Returns:
    the second operand of the union

### setSystemId

    public void setSystemId(java.lang.String systemId)

  Override method to set the system ID, so it's set on both halves

  Overrides:
    `setSystemId` in class `Pattern`
  Parameters:
    `systemId` - the URI of the module containing the pattern

### setLineNumber

    public void setLineNumber(int lineNumber)

  Override method to set the system ID, so it's set on both halves

  Overrides:
    `setLineNumber` in class `Pattern`
  Parameters:
    `lineNumber` - the line number of the pattern in the source module

### equals

    public boolean equals(java.lang.Object other)

  Determine whether this pattern is the same as another pattern

  Overrides:
    `equals` in class `java.lang.Object`
  Parameters:
    `other` - the other object

### hashCode

    public int hashCode()

  Hashcode supporting equals()

  Overrides:
    `hashCode` in class `java.lang.Object`

Copyright (c) Saxonica Limited. All rights reserved.