net.sf.saxon.regex

## Class ARegularExpression

- java.lang.Object
- - net.sf.saxon.regex.ARegularExpression

- All Implemented Interfaces:
    Serializable, RegularExpression

      public class ARegularExpression
      extends Object
      implements RegularExpression

  Glue class to interface the Jakarta regex engine to Saxon (The prefix 'A' indicates an Apache regular expression, as distinct from a JDK regular expression).
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ARegularExpression(CharSequence pattern, String flags, String hostLanguage, List<String> warnings)` Create and compile a regular expression

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `RegexIterator` | `analyze(CharSequence input)` Use this regular expression to analyze an input string, in support of the XSLT analyze-string instruction.
    `boolean` | `containsMatch(CharSequence input)` Determine whether the regular expression contains a match of a given string
    `boolean` | `matches(CharSequence input)` Determine whether the regular expression matches a given string in its entirety
    `CharSequence` | `replace(CharSequence input, CharSequence replacement)` Replace all substrings of a supplied input string that match the regular expression with a replacement string.
    `SequenceIterator<StringValue>` | `tokenize(CharSequence input)` Use this regular expression to tokenize an input string.

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

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

- - ### Constructor Detail

    - #### ARegularExpression

          public ARegularExpression(CharSequence pattern,
                            String flags,
                            String hostLanguage,
                            List<String> warnings)
                             throws XPathException

      Create and compile a regular expression
      Parameters:
        `pattern` - the regular expression
        `flags` - the flags (ixsmq)
        `hostLanguage` - one of "XP20", "XP30", "XSD10", "XSD11". Also allow combinations, e.g. "XP20/XSD11".
        `warnings` - a list to be populated with any warnings arising during compilation of the regex
      Throws:
        `XPathException` - if the regular expression is invalid

  - ### Method Detail

    - #### matches

          public boolean matches(CharSequence input)

      Determine whether the regular expression matches a given string in its entirety
      Specified by:
        `matches` in interface `RegularExpression`
      Parameters:
        `input` - the string to match
      Returns:
        true if the string matches, false otherwise

    - #### containsMatch

          public boolean containsMatch(CharSequence input)

      Determine whether the regular expression contains a match of a given string
      Specified by:
        `containsMatch` in interface `RegularExpression`
      Parameters:
        `input` - the string to match
      Returns:
        true if the string matches, false otherwise

    - #### tokenize

          public SequenceIterator<StringValue> tokenize(CharSequence input)

      Use this regular expression to tokenize an input string.
      Specified by:
        `tokenize` in interface `RegularExpression`
      Parameters:
        `input` - the string to be tokenized
      Returns:
        a SequenceIterator containing the resulting tokens, as objects of type StringValue

    - #### analyze

          public RegexIterator analyze(CharSequence input)

      Use this regular expression to analyze an input string, in support of the XSLT analyze-string instruction. The resulting RegexIterator provides both the matching and non-matching substrings, and allows them to be distinguished. It also provides access to matched subgroups.
      Specified by:
        `analyze` in interface `RegularExpression`
      Parameters:
        `input` - the character string to be analyzed using the regular expression
      Returns:
        an iterator over matched and unmatched substrings

    - #### replace

          public CharSequence replace(CharSequence input,
                             CharSequence replacement)
                               throws XPathException

      Replace all substrings of a supplied input string that match the regular expression with a replacement string.
      Specified by:
        `replace` in interface `RegularExpression`
      Parameters:
        `input` - the input string on which replacements are to be performed
        `replacement` - the replacement string in the format of the XPath replace() function
      Returns:
        the result of performing the replacement
      Throws:
        `XPathException` - if the replacement string is invalid

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