JRegularExpression

java.lang.Object
- net.sf.saxon.java.JRegularExpression

All Implemented Interfaces:

java.io.Serializable, RegularExpression
```
public class JRegularExpression
extends java.lang.Object
implements RegularExpression
```
A compiled regular expression implemented using the Java JDK regex package

See Also:

Serialized Form

Field Summary
- Fields inherited from interface net.sf.saxon.regex.RegularExpression
  NATIVE_SYNTAX, XML_SCHEMA_SYNTAX, XPATH_SYNTAX

Constructor Summary

Constructors
Constructor	Description
`JRegularExpression(java.lang.CharSequence regex, int xmlVersion, int syntax, int flagBits)`	Create (compile) a regular expression
`JRegularExpression(java.lang.String javaRegex, int flagBits)`	Create a regular expression, starting with an already-translated Java regex

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`RegexIterator`	`analyze(java.lang.CharSequence input)`	Use this regular expression to analyze an input string, in support of the XSLT analyze-string instruction.
`boolean`	`containsMatch(java.lang.CharSequence input)`	Determine whether the regular expression contains a match for a given string
`int`	`getFlagBits()`	Get the flag bits as used by the Java regular expression engine
`java.lang.String`	`getJavaRegularExpression()`	Get the Java regular expression (after translation from an XPath regex, but before compilation)
`boolean`	`matches(java.lang.CharSequence input)`	Determine whether the regular expression match a given string in its entirety
`java.lang.CharSequence`	`replace(java.lang.CharSequence input, java.lang.CharSequence replacement)`	Replace all substrings of a supplied input string that match the regular expression with a replacement string.
`static int`	`setFlags(java.lang.CharSequence inFlags)`	Set the Java flags from the supplied XPath flags.
`SequenceIterator`	`tokenize(java.lang.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
  - JRegularExpression
```
public JRegularExpression(java.lang.String javaRegex,
                          int flagBits)
```
    Create a regular expression, starting with an already-translated Java regex
    
    Parameters:
    
    javaRegex - the regular expression after translation to Java notation
    
    flagBits - the option bits, derived from the user-specified flags
  - JRegularExpression
```
public JRegularExpression(java.lang.CharSequence regex,
                          int xmlVersion,
                          int syntax,
                          int flagBits)
                   throws XPathException
```
    Create (compile) a regular expression
    
    Parameters:
    
    regex - the source text of the regular expression, in XML Schema or XPath syntax
    
    xmlVersion - indicates whether \i and \c have their XML 1.0 or XML 1.1 meanings
    
    syntax - indicates whether XPath, XML Schema, or Java native regular expression syntax is to be used
    
    flagBits - the flags argument translated to the Java bit-significant integer representation
    
    Throws:
    
    XPathException - if the syntax of the regular expression or flags is incorrect
- Method Detail
  - getJavaRegularExpression
```
public java.lang.String getJavaRegularExpression()
```
    Get the Java regular expression (after translation from an XPath regex, but before compilation)
    
    Returns:
    
    the regular expression in Java notation
  - getFlagBits
```
public int getFlagBits()
```
    Get the flag bits as used by the Java regular expression engine
    
    Returns:
    
    the flag bits
  - analyze
```
public RegexIterator analyze(java.lang.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
  - containsMatch
```
public boolean containsMatch(java.lang.CharSequence input)
```
    Determine whether the regular expression contains a match for a given string
    
    Specified by:
    
    containsMatch in interface RegularExpression
    
    Parameters:
    
    input - the string to match
    
    Returns:
    
    true if the string matches, false otherwise
  - matches
```
public boolean matches(java.lang.CharSequence input)
```
    Determine whether the regular expression match 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
  - replace
```
public java.lang.CharSequence replace(java.lang.CharSequence input,
                                      java.lang.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
  - tokenize
```
public SequenceIterator tokenize(java.lang.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
  - setFlags
```
public static int setFlags(java.lang.CharSequence inFlags)
                    throws XPathException
```
    Set the Java flags from the supplied XPath flags.
    
    Parameters:
    
    inFlags - the flags as a string, e.g. "im"
    
    Returns:
    
    the flags as a bit-significant integer
    
    Throws:
    
    XPathException - if the supplied value is invalid

Class JRegularExpression

Field Summary

Fields inherited from interface net.sf.saxon.regex.RegularExpression

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

JRegularExpression

JRegularExpression

Method Detail

getJavaRegularExpression

getFlagBits

analyze

containsMatch

matches

replace

tokenize

setFlags