Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.functions.regex
Class JRegularExpression

    java.lang.Object
      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)

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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