TPattern (TeaVM Java class library 0.6.1 API)

java.lang.Object
- org.teavm.classlib.java.util.regex.TPattern

All Implemented Interfaces:

Serializable
```
public final class TPattern
extends Object
implements Serializable
```
Represents a pattern used for matching, searching, or replacing strings. Patterns are specified in terms of regular expressions and compiled using an instance of this class. They are then used in conjunction with a TMatcher to perform the actual search.
A typical use case looks like this:
```
 Pattern p = Pattern.compile("Hello, A[a-z]*!");

 Matcher m = p.matcher("Hello, Android!");
 boolean b1 = m.matches(); // true

 m.setInput("Hello, Robot!");
 boolean b2 = m.matches(); // false
 
```
The above code could also be written in a more compact fashion, though this variant is less efficient, since Pattern and Matcher objects are created on the fly instead of being reused. fashion:
```
 boolean b1 = Pattern.matches("Hello, A[a-z]*!", "Hello, Android!"); // true
 boolean b2 = Pattern.matches("Hello, A[a-z]*!", "Hello, Robot!"); // false
 
```
See Also:

TMatcher, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CANON_EQ` This constant specifies that a character in a `Pattern` and a character in the input string only match if they are canonically equivalent.
`static int`	`CASE_INSENSITIVE` This constant specifies that a `Pattern` is matched case-insensitively.
`static int`	`COMMENTS` This constant specifies that a `Pattern` may contain whitespace or comments.
`static int`	`DOTALL` This constant specifies that the '.' meta character matches arbitrary characters, including line endings, which is normally not the case.
`static int`	`LITERAL` This constant specifies that the whole `Pattern` is to be taken literally, that is, all meta characters lose their meanings.
`static int`	`MULTILINE` This constant specifies that the meta characters '^' and '$' match only the beginning and end end of an input line, respectively.
`static int`	`UNICODE_CASE` This constant specifies that a `Pattern` is matched case-insensitively with regard to all Unicode characters.
`static int`	`UNIX_LINES` This constant specifies that a pattern matches Unix line endings ('\n') only against the '

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static TPattern`	`compile(String pattern)` Compiles a regular expression, creating a new Pattern instance in the process.
`static TPattern`	`compile(String pattern, int flags)` Compiles a regular expression, creating a new `Pattern` instance in the process.
`int`	`flags()` Returns the flags that have been set for this `Pattern`.
`TMatcher`	`matcher(CharSequence input)` Returns a `TMatcher` for the `Pattern` and a given input.
`static boolean`	`matches(String regex, CharSequence input)` Tries to match a given regular expression against a given input.
`String`	`pattern()` Returns the regular expression that was compiled into this `Pattern`.
`static String`	`quote(String s)` Quotes a given string using "\Q" and "\E", so that all other meta-characters lose their special meaning.
`String[]`	`split(CharSequence input)` Splits a given input around occurrences of a regular expression.
`String[]`	`split(CharSequence inputSeq, int limit)` Splits the given input sequence around occurrences of the `Pattern` .
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - UNIX_LINES
```
public static final int UNIX_LINES
```
    This constant specifies that a pattern matches Unix line endings ('\n') only against the '.', '^', and '$' meta characters.
    
    See Also:
    
    Constant Field Values
  - CASE_INSENSITIVE
```
public static final int CASE_INSENSITIVE
```
    This constant specifies that a Pattern is matched case-insensitively. That is, the patterns "a+" and "A+" would both match the string "aAaAaA".
    
    See Also:
    
    Constant Field Values
  - COMMENTS
```
public static final int COMMENTS
```
    This constant specifies that a Pattern may contain whitespace or comments. Otherwise comments and whitespace are taken as literal characters.
    
    See Also:
    
    Constant Field Values
  - MULTILINE
```
public static final int MULTILINE
```
    This constant specifies that the meta characters '^' and '$' match only the beginning and end end of an input line, respectively. Normally, they match the beginning and the end of the complete input.
    
    See Also:
    
    Constant Field Values
  - LITERAL
```
public static final int LITERAL
```
    This constant specifies that the whole Pattern is to be taken literally, that is, all meta characters lose their meanings.
    
    See Also:
    
    Constant Field Values
  - DOTALL
```
public static final int DOTALL
```
    This constant specifies that the '.' meta character matches arbitrary characters, including line endings, which is normally not the case.
    
    See Also:
    
    Constant Field Values
  - UNICODE_CASE
```
public static final int UNICODE_CASE
```
    This constant specifies that a Pattern is matched case-insensitively with regard to all Unicode characters. It is used in conjunction with the CASE_INSENSITIVE constant to extend its meaning to all Unicode characters.
    
    See Also:
    
    Constant Field Values
  - CANON_EQ
```
public static final int CANON_EQ
```
    This constant specifies that a character in a Pattern and a character in the input string only match if they are canonically equivalent.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - matcher
```
public TMatcher matcher(CharSequence input)
```
    Returns a TMatcher for the Pattern and a given input. The Matcher can be used to match the Pattern against the whole input, find occurrences of the Pattern in the input, or replace parts of the input.
    
    Parameters:
    
    input - the input to process.
    
    Returns:
    
    the resulting Matcher.
  - split
```
public String[] split(CharSequence inputSeq,
                      int limit)
```
    Splits the given input sequence around occurrences of the Pattern . The function first determines all occurrences of the Pattern inside the input sequence. It then builds an array of the "remaining" strings before, in-between, and after these occurrences. An additional parameter determines the maximal number of entries in the resulting array and the handling of trailing empty strings.
    Parameters:
    
    inputSeq - the input sequence.
    limit - Determines the maximal number of entries in the resulting array.
    
    For n > 0, it is guaranteed that the resulting array contains at most n entries.
    For n < 0, the length of the resulting array is exactly the number of occurrences of the Pattern +1. All entries are included.
    For n == 0, the length of the resulting array is at most the number of occurrences of the Pattern +1. Empty strings at the end of the array are not included.
    Returns:
    
    the resulting array.
  - split
```
public String[] split(CharSequence input)
```
    Splits a given input around occurrences of a regular expression. This is a convenience method that is equivalent to calling the method split(java.lang.CharSequence, int) with a limit of 0.
    
    Parameters:
    
    input - the input sequence.
    
    Returns:
    
    the resulting array.
  - pattern
```
public String pattern()
```
    Returns the regular expression that was compiled into this Pattern.
    
    Returns:
    
    the regular expression.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - flags
```
public int flags()
```
    Returns the flags that have been set for this Pattern.
    
    Returns:
    
    the flags that have been set. A combination of the constants defined in this class.
    
    See Also:
    
    CANON_EQ, CASE_INSENSITIVE, COMMENTS, DOTALL, LITERAL, MULTILINE, UNICODE_CASE, UNIX_LINES
  - compile
```
public static TPattern compile(String pattern,
                               int flags)
                        throws TPatternSyntaxException
```
    Compiles a regular expression, creating a new Pattern instance in the process. Allows to set some flags that modify the behavior of the Pattern.
    
    Parameters:
    
    pattern - the regular expression.
    
    flags - the flags to set. Basically, any combination of the constants defined in this class is valid.
    
    Returns:
    
    the new Pattern instance.
    
    Throws:
    
    TPatternSyntaxException - if the regular expression is syntactically incorrect.
    
    See Also:
    
    CANON_EQ, CASE_INSENSITIVE, COMMENTS, DOTALL, LITERAL, MULTILINE, UNICODE_CASE, UNIX_LINES
  - compile
```
public static TPattern compile(String pattern)
```
    Compiles a regular expression, creating a new Pattern instance in the process. This is actually a convenience method that calls compile(String, int) with a flags value of zero.
    
    Parameters:
    
    pattern - the regular expression.
    
    Returns:
    
    the new Pattern instance.
    
    Throws:
    
    TPatternSyntaxException - if the regular expression is syntactically incorrect.
  - matches
```
public static boolean matches(String regex,
                              CharSequence input)
```
    Tries to match a given regular expression against a given input. This is actually nothing but a convenience method that compiles the regular expression into a Pattern, builds a TMatcher for it, and then does the match. If the same regular expression is used for multiple operations, it is recommended to compile it into a Pattern explicitly and request a reusable Matcher.
    
    Parameters:
    
    regex - the regular expression.
    
    input - the input to process.
    
    Returns:
    
    true if and only if the Pattern matches the input.
    
    See Also:
    
    compile(java.lang.String, int), TMatcher.matches()
  - quote
```
public static String quote(String s)
```
    Quotes a given string using "\Q" and "\E", so that all other meta-characters lose their special meaning. If the string is used for a Pattern afterwards, it can only be matched literally.
    
    Parameters:
    
    s - the string to quote.
    
    Returns:
    
    the quoted string.

Class TPattern

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

UNIX_LINES

CASE_INSENSITIVE

COMMENTS

MULTILINE

LITERAL

DOTALL

UNICODE_CASE

CANON_EQ

Method Detail

matcher

split

split

pattern

toString

flags

compile

compile

matches

quote