net.sf.saxon.functions.regex
Class JRegularExpression

java.lang.Object
  extended by net.sf.saxon.functions.regex.JRegularExpression
All Implemented Interfaces:
Serializable, RegularExpression

public class JRegularExpression
extends 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.functions.regex.RegularExpression
EXPAND_COMPLEMENT_BLOCKS, JAVA_SYNTAX, XML11, XPATH20, XPATH30, XSD11
 
Constructor Summary
JRegularExpression(CharSequence regex, int options, int flagBits, List<RegexSyntaxException> warnings)
          Create (compile) an XSD/XPath regular expression
JRegularExpression(String javaRegex, int flagBits)
          Create a regular expression, starting with an already-translated Java regex.
 
Method Summary
 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 for a given string
 int getFlagBits()
          Get the flag bits as used by the Java regular expression engine
 String getJavaRegularExpression()
          Get the Java regular expression (after translation from an XPath regex, but before compilation)
static void main(String[] args)
           
 boolean matches(CharSequence input)
          Determine whether the regular expression match 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.
static int setFlags(CharSequence inFlags)
          Set the Java flags from the supplied XPath flags.
 SequenceIterator 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

JRegularExpression

public JRegularExpression(String javaRegex,
                          int flagBits)
Create a regular expression, starting with an already-translated Java regex. NOTE: this constructor is called from compiled XQuery code

Parameters:
javaRegex - the regular expression after translation to Java notation
flagBits - the option bits, derived from the user-specified flags

JRegularExpression

public JRegularExpression(CharSequence regex,
                          int options,
                          int flagBits,
                          List<RegexSyntaxException> warnings)
                   throws XPathException
Create (compile) an XSD/XPath regular expression

Parameters:
regex - the source text of the regular expression, in XML Schema or XPath syntax
options - flags indicting the regex dialect accepted
flagBits - the flags argument translated to the Java bit-significant integer representation
warnings - a list to contain any warnings generated. If no list is supplied, this indicates that the caller is not interested in knowing about any warnings.
Throws:
XPathException - if the syntax of the regular expression or flags is incorrect
Method Detail

getJavaRegularExpression

public 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(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(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(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 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

tokenize

public SequenceIterator 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

setFlags

public static int setFlags(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

main

public static void main(String[] args)


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