TokenPattern (Teamscale Check Framework API)

java.lang.Object
- eu.cqse.check.framework.util.tokens.TokenPattern

```
public class TokenPattern
extends java.lang.Object
```
A pattern that can be applied like a regular expression to a token stream. This class is not fully redundant to TokenTypePattern for two reasons:
- It allows matching nested structures, e.g. parentheses, with skipNested(Object, Object, boolean)
- It allows named capture groups, something which is not currently possible with Java 7: http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8013252

Constructor Summary

Constructors
Constructor and Description

TokenPattern()

Constructors
Constructor and Description
`TokenPattern()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`TokenPattern`	`alternative(java.lang.Object... matchTerms)` Adds a new alternative pattern part that tries the given match terms one after the other and stops as soon as one of them matches.
`TokenPattern`	`beginningOfStream()` Adds a new pattern part that matches the beginning of the token stream (i.e.
`TokenPattern`	`endOfStream()` Adds a new pattern part that matches the end of the token stream (i.e.
`java.util.List<TokenPatternMatch>`	`findAll(java.util.List<IToken> tokens)` Matches the pattern at all positions in the given token stream and returns the found matches.
`TokenPatternMatch`	`findFirstMatch(java.util.List<IToken> tokens)` Matches the pattern at all positions in the given token stream and returns the first found match or `null` if no match happened.
`java.util.List<TokenPatternMatch>`	`findNonOverlappingMatches(java.util.List<IToken> tokens)` Finds and returns non-overlapping matches in the tokens.
`TokenPattern`	`group(int groupIndex)` Specifies that the last added subpattern should be appended to the group with the given index.
`TokenPatternMatch`	`matchAtCurrentPosition(TokenStream stream)` Matches the pattern at the start position of the token stream.
`TokenPatternMatch`	`matchAtStartOf(java.util.List<IToken> tokens)` Matches the pattern at the start position of the given tokens.
`boolean`	`matchesAnywhere(java.util.List<IToken> tokens)` Returns `true` if the pattern matches at least once in the given token stream.
`TokenPattern`	`notAtBeginningOfStream()` Adds a new pattern part that matches anything but the beginning of the token stream (i.e.
`TokenPattern`	`notFollowedBy(java.lang.Object matchTerm)` Adds a new pattern part that matches if the last matched token is not followed by a token that matches the given term.
`TokenPattern`	`notPrecededBy(java.lang.Object matchTerm)` Adds a new pattern part that matches if the last matched token is not preceded by a token that matches the given term.
`TokenPattern`	`optional(java.lang.Object... matchTerms)` Adds a new optional pattern part that matches the given terms zero times or once in the given order.
`TokenPattern`	`regex(java.lang.String regex)` Adds a new pattern part that matches token text with specified regex.
`TokenPattern`	`repeated(java.lang.Object... matchTerms)` Adds a new "repeated" pattern part that matches the given terms zero or more times in the given order.
`TokenPattern`	`repeatedAtLeastOnce(java.lang.Object... matchTerms)` Matches the given terms one or more times.
`TokenPattern`	`sequence(java.lang.Object... matchTerms)` Adds a new pattern part that matches the given sequence of terms exactly once in the given order.
`TokenPattern`	`skipNested(java.lang.Object openTerm, java.lang.Object closeTerm, boolean optional)` Adds a new pattern part that consumes nested structures.
`TokenPattern`	`skipTo(java.lang.Object... matchTerms)` Adds a new pattern part that consumes anything until it encounters one of the given match terms.
`static TokenPatternBase`	`text(java.lang.String tokenText)` Returns a new Token pattern that matches on tokens that have exactly the given text.
`java.lang.String`	`toString()`

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

- Constructor Detail
  - TokenPattern
```
public TokenPattern()
```
- Method Detail
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - findAll
```
public java.util.List<TokenPatternMatch> findAll(java.util.List<IToken> tokens)
```
    Matches the pattern at all positions in the given token stream and returns the found matches. This also finds overlapping matches. Given the token sequence const int a and pattern (KEYWORD)* IDENTIFIFER, this method will return 3 matches const int a, int a & a.
  - findFirstMatch
```
public TokenPatternMatch findFirstMatch(java.util.List<IToken> tokens)
```
    Matches the pattern at all positions in the given token stream and returns the first found match or null if no match happened.
  - findNonOverlappingMatches
```
public java.util.List<TokenPatternMatch> findNonOverlappingMatches(java.util.List<IToken> tokens)
```
    Finds and returns non-overlapping matches in the tokens. Given the token sequence const int a and pattern (KEYWORD)* IDENTIFIFER, this method will return only one match contrary to findAll(java.util.List<eu.cqse.check.framework.scanner.IToken>) that will return 3 matches. The search starts at beginning of token stream say point x. If a match is found say at position x + 5, the next search starts just after the position of the previous successful search (x + 6). If no match is found, the search continues from position x + 1. This ensures no overlapping matches.
  - matchAtStartOf
```
public TokenPatternMatch matchAtStartOf(java.util.List<IToken> tokens)
```
    Matches the pattern at the start position of the given tokens. Returns the found match or null if no match happened.
  - matchAtCurrentPosition
```
public TokenPatternMatch matchAtCurrentPosition(TokenStream stream)
```
    Matches the pattern at the start position of the token stream. Returns the found match or null if no match happened. The stream's position is preserved.
  - matchesAnywhere
```
public boolean matchesAnywhere(java.util.List<IToken> tokens)
```
    Returns true if the pattern matches at least once in the given token stream.
  - group
```
public TokenPattern group(int groupIndex)
```
    Specifies that the last added subpattern should be appended to the group with the given index. The group index may be any integer number. Group indices are not required to be ordered or continuous.
  - skipTo
```
public TokenPattern skipTo(java.lang.Object... matchTerms)
```
    Adds a new pattern part that consumes anything until it encounters one of the given match terms. The stop token matching one of the given terms is also consumed. A group applied to this pattern will only contain the stop token.
    
    Parameters:
    
    matchTerms - a list of match terms which must match in order. These may be instances of ETokenType, ETokenType.ETokenClass, or sets of them, as well as TokenPatterns.
  - skipNested
```
public TokenPattern skipNested(java.lang.Object openTerm,
                               java.lang.Object closeTerm,
                               boolean optional)
```
    Adds a new pattern part that consumes nested structures.
    
    Parameters:
    
    openTerm - a match term that identifies the opening braces. May be an instance of ETokenType, ETokenType.ETokenClass, or a set of them, as well as an TokenPattern.
    
    closeTerm - a match term that identifies the closing braces. May be an instance of ETokenType, ETokenType.ETokenClass, or a set of them, as well as an TokenPattern.
    
    optional - if this is false, the nested structure must be present or the pattern will not match. If this is true, this pattern may return an empty match.
  - repeated
```
public TokenPattern repeated(java.lang.Object... matchTerms)
```
    Adds a new "repeated" pattern part that matches the given terms zero or more times in the given order.
    
    Parameters:
    
    matchTerms - a list of match terms which must match in order. These may be instances of ETokenType, ETokenType.ETokenClass, or sets of them, as well as TokenPatterns.
  - sequence
```
public TokenPattern sequence(java.lang.Object... matchTerms)
```
    Adds a new pattern part that matches the given sequence of terms exactly once in the given order.
    
    Parameters:
    
    matchTerms - a list of match terms which must match in order. These may be instances of ETokenType, ETokenType.ETokenClass, or sets of them, as well as TokenPatterns.
  - endOfStream
```
public TokenPattern endOfStream()
```
    Adds a new pattern part that matches the end of the token stream (i.e. there are no more tokens to match).
  - beginningOfStream
```
public TokenPattern beginningOfStream()
```
    Adds a new pattern part that matches the beginning of the token stream (i.e. no tokens have been consumed so far).
  - notAtBeginningOfStream
```
public TokenPattern notAtBeginningOfStream()
```
    Adds a new pattern part that matches anything but the beginning of the token stream (i.e. at least one token has been consumed so far).
  - notFollowedBy
```
public TokenPattern notFollowedBy(java.lang.Object matchTerm)
```
    Adds a new pattern part that matches if the last matched token is not followed by a token that matches the given term. This pattern part does not consume any tokens.
    
    Parameters:
    
    matchTerm - May be an instance of ETokenType, ETokenType.ETokenClass, or a set of them, as well as a TokenPattern.
  - notPrecededBy
```
public TokenPattern notPrecededBy(java.lang.Object matchTerm)
```
    Adds a new pattern part that matches if the last matched token is not preceded by a token that matches the given term. This pattern part does not consume any tokens. NOTE: passing a TokenPattern to this function will not result in an exception, but it will not yield the intuitive result. The given pattern will be matched against the token stream, starting with the token preceding the current token. It is therefore discouraged to pass a TokenPattern to this function as it makes understanding the pattern difficult.
    
    Parameters:
    
    matchTerm - May be an instance of ETokenType, ETokenType.ETokenClass, or a set of them, but usually not a TokenPattern.
  - alternative
```
public TokenPattern alternative(java.lang.Object... matchTerms)
```
    Adds a new alternative pattern part that tries the given match terms one after the other and stops as soon as one of them matches.
    
    Parameters:
    
    matchTerms - a list of match terms which must match in order. These may be instances of ETokenType, ETokenType.ETokenClass, or sets of them, as well as TokenPatterns.
  - optional
```
public TokenPattern optional(java.lang.Object... matchTerms)
```
    Adds a new optional pattern part that matches the given terms zero times or once in the given order.
    
    Parameters:
    
    matchTerms - a list of match terms which must match in order. These may be instances of ETokenType, ETokenType.ETokenClass, or sets of them, as well as TokenPatterns.
  - regex
```
public TokenPattern regex(java.lang.String regex)
```
    Adds a new pattern part that matches token text with specified regex.
    
    Parameters:
    
    regex - string to contain in token text.
  - repeatedAtLeastOnce
```
public TokenPattern repeatedAtLeastOnce(java.lang.Object... matchTerms)
```
    Matches the given terms one or more times. Shorthand for .sequence(matchTerms).repeated(matchTerms)
  - text
```
public static TokenPatternBase text(java.lang.String tokenText)
```
    Returns a new Token pattern that matches on tokens that have exactly the given text.

Class TokenPattern

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TokenPattern

Method Detail

toString

findAll

findFirstMatch

findNonOverlappingMatches

matchAtStartOf

matchAtCurrentPosition

matchesAnywhere

group

skipTo

skipNested

repeated

sequence

endOfStream

beginningOfStream

notAtBeginningOfStream

notFollowedBy

notPrecededBy

alternative

optional

regex

repeatedAtLeastOnce

text