Package net.sf.saxon.regex

Class ARegularExpression

  • All Implemented Interfaces:
    RegularExpression
    public class ARegularExpression
extends java.lang.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).

    • Constructor Summary

      Constructors 
      Constructor Description
      ARegularExpression​(UnicodeString pattern, java.lang.String flags, java.lang.String hostLanguage, java.util.List<java.lang.String> warnings, Configuration config)
      Create and compile a regular expression

    • Constructor Detail

      • ARegularExpression

        public ARegularExpression​(UnicodeString pattern,
                          java.lang.String flags,
                          java.lang.String hostLanguage,
                          java.util.List<java.lang.String> warnings,
                          Configuration config)
                   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
        config - the Saxon Configuration: may be null
        Throws:
        XPathException - if the regular expression is invalid

    • Method Detail

      • compile

        public static ARegularExpression compile​(java.lang.String pattern,
                                         java.lang.String flags)
        Static factory method intended for simple static regular expressions known to be correct
        Parameters:
        pattern - the regular expression, using XPath 3.1 syntax
        flags - regular expression flags
        Returns:
        the compiled regular expression
        Throws:
        java.lang.IllegalArgumentException - if the regular expression or the flags are invalid

      • compile

        public static ARegularExpression compile​(UnicodeString pattern,
                                         java.lang.String flags)
        Static factory method intended for simple static regular expressions known to be correct

      • matches

        public boolean matches​(UnicodeString 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​(UnicodeString 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 AtomicIterator tokenize​(UnicodeString 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​(UnicodeString 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 UnicodeString replace​(UnicodeString input,
                             UnicodeString 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

      • replaceWith

        public UnicodeString replaceWith​(UnicodeString input,
                                 java.util.function.Function<UnicodeString,​UnicodeString> replacer)
                          throws XPathException
        Replace all substrings of a supplied input string that match the regular expression with a replacement string.
        Specified by:
        replaceWith in interface RegularExpression
        Parameters:
        input - the input string on which replacements are to be performed
        replacer - 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

      • getFlags

        public java.lang.String getFlags()
        Get the flags used at the time the regular expression was compiled.
        Specified by:
        getFlags in interface RegularExpression
        Returns:
        a string containing the flags

      • isPlatformNative

        public boolean isPlatformNative()
        Ask whether the regular expression is using platform-native syntax (Java or .NET), or XPath syntax
        Specified by:
        isPlatformNative in interface RegularExpression
        Returns:
        true if using platform-native syntax