net.sf.saxon.functions

## Class Matches

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - net.sf.saxon.expr.FunctionCall
    - - net.sf.saxon.functions.SystemFunctionCall
      - - net.sf.saxon.functions.Matches

- All Implemented Interfaces:
    Serializable, SourceLocator, LocationProvider, SaxonLocator, Callable, InstructionInfo, Locator

      public class Matches
      extends SystemFunctionCall

  This class implements the matches() function for regular expression matching
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.functions.SystemFunctionCall

      `operation`

    - ### Fields inherited from class net.sf.saxon.expr.FunctionCall

      `argument`

    - ### Fields inherited from class net.sf.saxon.expr.Expression

      `EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, EVENT_FEED_METHOD, INHERITED_CONTEXT, INSPECTION_CONTEXT, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, NAVIGATION_CONTEXT, NODE_VALUE_CONTEXT, PROCESS_METHOD, PUSH_SELECTION, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, W3C_CONSUMING, W3C_FREE_RANGING, W3C_GROUP_CONSUMING, W3C_MOTIONLESS, WATCH_METHOD`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Matches()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Sequence` | `call(XPathContext context, Sequence[] arguments)` Evaluate the expression
    `boolean` | `evalMatches(AtomicValue input, AtomicValue regex, CharSequence flags, XPathContext context)` Interface used by compiled bytecode
    `BooleanValue` | `evaluateItem(XPathContext c)` Evaluate the matches() function to give a Boolean value.
    `RegularExpression` | `getCompiledRegularExpression()` Get the compiled regular expression, returning null if the regex has not been compiled
    `ExpressionCompiler` | `getExpressionCompiler()` Return the compiler of the Matches expression
    `Expression` | `optimize(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Perform optimisation of an expression and its subexpressions.
    `Expression` | `simplify(ExpressionVisitor visitor)` Simplify and validate.
    `static RegularExpression` | `tryToCompile(Expression[] args, int patternArg, int flagsArg, StaticContext env)` Try to precompile the arguments to the function.

    - ### Methods inherited from class net.sf.saxon.functions.SystemFunctionCall

      `addContextDocumentArgument, addDocToPathMap, bindStaticContext, checkArguments, computeCardinality, computeSpecialProperties, copy, equalOrNull, equals, getContextNode, getConvertingCallable, getDefaultArgumentNode, getDetails, getErrorCodeForTypeErrors, getFunctionItemType, getImplementationMethod, getItemType, getOperation, getRequiredType, iterateSubExpressionInfo, makeSystemFunction, setDetails, useContextItemAsDefault`

    - ### Methods inherited from class net.sf.saxon.expr.FunctionCall

      `addExternalFunctionCallToPathMap, checkArgumentCount, explain, getArguments, getDisplayName, getExpressionName, getFunctionName, getNumberOfArguments, hashCode, iterateSubExpressions, preEvaluate, promote, replaceSubExpression, setArguments, setFunctionName, simplifyArguments, toString, typeCheck`

    - ### Methods inherited from class net.sf.saxon.expr.Expression

      `addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExecutable, getHostLanguage, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getStreamability, getStreamingAdjunct, getSystemId, getSystemId, hasVariableBinding, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterate, iterateEvents, markTailFunctionCalls, process, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, toPattern, toStreamingPattern, typeError`

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

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

- - ### Constructor Detail

    - #### Matches

          public Matches()

  - ### Method Detail

    - #### simplify

          public Expression simplify(ExpressionVisitor visitor)
                              throws XPathException

      Simplify and validate. This is a pure function so it can be simplified in advance if the arguments are known
      Overrides:
        `simplify` in class `FunctionCall`
      Parameters:
        `visitor` - an expression visitor
      Returns:
        the simplified expression
      Throws:
        `XPathException` - if any error is found (e.g. invalid regular expression)

    - #### optimize

          public Expression optimize(ExpressionVisitor visitor,
                            ExpressionVisitor.ContextItemType contextItemType)
                              throws XPathException

      Perform optimisation of an expression and its subexpressions.

      This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

      Overrides:
        `optimize` in class `SystemFunctionCall`
      Parameters:
        `visitor` - an expression visitor
        `contextItemType` - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to `Type.ITEM_TYPE`
      Returns:
        the original expression, rewritten if appropriate to optimize execution
      Throws:
        `XPathException` - if an error is discovered during this phase (typically a type error)

    - #### getCompiledRegularExpression

          public RegularExpression getCompiledRegularExpression()

      Get the compiled regular expression, returning null if the regex has not been compiled
      Returns:
        the compiled regular expression, or null

    - #### evaluateItem

          public BooleanValue evaluateItem(XPathContext c)
                                    throws XPathException

      Evaluate the matches() function to give a Boolean value.
      Overrides:
        `evaluateItem` in class `Expression`
      Parameters:
        `c` - The dynamic evaluation context
      Returns:
        the result as a BooleanValue, or null to indicate the empty sequence
      Throws:
        `XPathException` - on an error

    - #### evalMatches

          public boolean evalMatches(AtomicValue input,
                            AtomicValue regex,
                            CharSequence flags,
                            XPathContext context)
                              throws XPathException

      Interface used by compiled bytecode
      Parameters:
        `input` - the value to be tested
        `regex` - the regular expression
        `flags` - the flags
        `context` - the dynamic context
      Returns:
        true if the string matches the regex
      Throws:
        `XPathException`

    - #### call

          public Sequence call(XPathContext context,
                      Sequence[] arguments)
                        throws XPathException

      Evaluate the expression
      Parameters:
        `context` - the dynamic evaluation context
        `arguments` - the values of the arguments, supplied as Sequences
      Returns:
        the result of the evaluation, in the form of a Sequence
      Throws:
        `XPathException` - if a dynamic error occurs during the evaluation of the expression

    - #### tryToCompile

          public static RegularExpression tryToCompile(Expression[] args,
                                       int patternArg,
                                       int flagsArg,
                                       StaticContext env)
                                                throws XPathException

      Try to precompile the arguments to the function. This method is shared by the implementations of the three XPath functions matches(), replace(), and tokenize().
      Parameters:
        `args` - the supplied arguments to the function, as an array
        `patternArg` - the position of the argument containing the regular expression
        `flagsArg` - the position of the argument containing the flags
        `env` - the static context
      Returns:
        the compiled regular expression, or null indicating that the information is not available statically so it cannot be precompiled
      Throws:
        `XPathException` - if any failure occurs, in particular, if the regular expression is invalid

    - #### getExpressionCompiler

          public ExpressionCompiler getExpressionCompiler()

      Return the compiler of the Matches expression
      Overrides:
        `getExpressionCompiler` in class `Expression`
      Returns:
        the relevant ExpressionCompiler

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.