PatternToken (LanguageTool 6.4-SNAPSHOT API)

java.lang.Object
- org.languagetool.rules.patterns.PatternToken

All Implemented Interfaces:

Cloneable
```
public class PatternToken
extends Object
implements Cloneable
```
A part of a pattern, represents the 'token' element of the grammar.xml.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class PatternToken.PosToken

Nested Classes
Modifier and Type	Class and Description
`static class`	`PatternToken.PosToken`

Field Summary

Fields
Modifier and Type Field and Description

static String UNKNOWN_TAG
Matches only tokens without any POS tag.

Fields
Modifier and Type	Field and Description
`static String`	`UNKNOWN_TAG` Matches only tokens without any POS tag.

Constructor Summary

Constructors
Constructor and Description
`PatternToken(String token, boolean caseSensitive, boolean regExp, boolean inflected)` Creates Element that is used to match tokens in the text.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Object`	`clone()`
`PatternToken`	`compile(AnalyzedTokenReadings token, Synthesizer synth)` Prepare PatternToken for matching by formatting its string token and POS (if the Element is supposed to refer to some other token).
`List<PatternToken>`	`getAndGroup()` Returns the group of elements linked with AND operator.
`ChunkTag`	`getChunkTag()`
`List<PatternToken>`	`getExceptionList()`
`Match`	`getMatch()`
`int`	`getMaxOccurrence()` The maximum number of times the element may occur.
`int`	`getMinOccurrence()` The minimum number of times the element needs to occur.
`boolean`	`getNegation()` see `setNegation(boolean)`
`List<PatternToken>`	`getOrGroup()` Returns the group of elements linked with OR operator.
`String`	`getPhraseName()` Gets the phrase the element is in.
`boolean`	`getPOSNegation()`
`String`	`getPOStag()`
`int`	`getSkipNext()` Gets the exception scope length.
`String`	`getString()`
`Map<String,List<String>>`	`getUniFeatures()` Get unification features and types.
`boolean`	`hasAndGroup()` Checks if this element has an AND group associated with it.
`boolean`	`hasCurrentOrNextExceptions()`
`boolean`	`hasExceptionList()`
`boolean`	`hasNextException()` Checks if the element has an exception for a next scope.
`boolean`	`hasOrGroup()` Checks if this element has an OR group associated with it.
`boolean`	`hasPreviousException()` Checks if the element has an exception for a previous token.
`boolean`	`isAndExceptionGroupMatched(AnalyzedToken token)` Enables testing multiple conditions specified by multiple element exceptions.
`boolean`	`isCaseSensitive()` Whether the element matches case sensitively.
`boolean`	`isExceptionMatched(AnalyzedToken token)` Checks whether an exception matches.
`boolean`	`isExceptionMatchedCompletely(AnalyzedToken token)` This method checks exceptions both in AND-group and the token.
`boolean`	`isInflected()`
`boolean`	`isInsideMarker()`
`boolean`	`isLastInUnification()`
`boolean`	`isMatched(AnalyzedToken token)` Checks whether the rule element matches the token given as a parameter.
`boolean`	`isMatchedByPreviousException(AnalyzedToken token)` Checks whether an exception for a previous token matches (in case the exception had scope == "previous").
`boolean`	`isMatchedByPreviousException(AnalyzedTokenReadings prevToken)` Checks whether an exception for a previous token matches all readings of a given token (in case the exception had scope == "previous").
`boolean`	`isMatchedByScopeNextException(AnalyzedToken token)` Checks whether a previously set exception matches (in case the exception had scope == "next").
`boolean`	`isPartOfPhrase()` Checks if the Element is in any phrase.
`boolean`	`isPOStagRegularExpression()` Tests whether the POS matches a regular expression.
`boolean`	`isReferenceElement()`
`boolean`	`isRegularExpression()` Tests whether the element matches a regular expression.
`boolean`	`isSentenceStart()` Checks if the token is a sentence start.
`boolean`	`isUnificationNeutral()` Determines whether the element should be silently ignored during unification, and simply added.
`boolean`	`isUnified()`
`boolean`	`isUniNegated()`
`boolean`	`isWhitespaceBefore(AnalyzedToken token)`
`void`	`setAndGroupElement(PatternToken andToken)`
`void`	`setChunkTag(ChunkTag chunkTag)`
`void`	`setExceptionSpaceBefore(boolean isWhite)` Sets the attribute on the exception that determines matching of patterns that depends on whether there was a space before the token matching the exception or not.
`void`	`setInsideMarker(boolean isInsideMarker)`
`void`	`setLastInUnification()`
`void`	`setMatch(Match match)` Sets the reference to another token.
`void`	`setMaxOccurrence(int i)` The maximum number of times this element may occur.
`void`	`setMinOccurrence(int i)` The minimum number of times this element may occur.
`void`	`setNegation(boolean negation)` Negates the matching so that non-matching elements match and vice-versa.
`void`	`setOrGroupElement(PatternToken orToken)`
`void`	`setPhraseName(String id)` Sets the phrase the element is in.
`void`	`setPosToken(PatternToken.PosToken posToken)`
`void`	`setSkipNext(int i)`
`void`	`setStringElement(String token)`
`void`	`setStringPosException(String token, boolean regExp, boolean inflected, boolean negation, boolean scopeNext, boolean scopePrevious, String posToken, boolean posRegExp, boolean posNegation, Boolean caseSensitivity)` Sets a string and/or pos exception for matching tokens.
`void`	`setUnification(Map<String,List<String>> uniFeatures)`
`void`	`setUnificationNeutral()` Sets the element as ignored during unification.
`void`	`setUniNegation()`
`void`	`setWhitespaceBefore(boolean isWhite)`
`String`	`toString()`

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

- Field Detail
  - UNKNOWN_TAG
```
public static final String UNKNOWN_TAG
```
    Matches only tokens without any POS tag.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - PatternToken
```
public PatternToken(String token,
                    boolean caseSensitive,
                    boolean regExp,
                    boolean inflected)
```
    Creates Element that is used to match tokens in the text.
    
    Parameters:
    
    token - String to be matched
    
    caseSensitive - true if the check is case-sensitive
    
    regExp - true if the check uses regular expressions
    
    inflected - true if the check refers to base forms (lemmas), note that token must be a base form for this to work
- Method Detail
  - clone
```
public Object clone()
             throws CloneNotSupportedException
```
    Overrides:
    
    clone in class Object
    
    Throws:
    
    CloneNotSupportedException
  - isMatched
```
public boolean isMatched(AnalyzedToken token)
```
    Checks whether the rule element matches the token given as a parameter.
    
    Parameters:
    
    token - AnalyzedToken to check matching against
    
    Returns:
    
    True if token matches, false otherwise.
  - isExceptionMatched
```
public boolean isExceptionMatched(AnalyzedToken token)
```
    Checks whether an exception matches.
    
    Parameters:
    
    token - AnalyzedToken to check matching against
    
    Returns:
    
    True if any of the exceptions matches (logical disjunction).
  - isAndExceptionGroupMatched
```
public boolean isAndExceptionGroupMatched(AnalyzedToken token)
```
    Enables testing multiple conditions specified by multiple element exceptions. Works as logical AND operator.
    
    Parameters:
    
    token - the token checked for exceptions.
    
    Returns:
    
    true if all conditions are met, false otherwise.
  - isExceptionMatchedCompletely
```
public boolean isExceptionMatchedCompletely(AnalyzedToken token)
```
    This method checks exceptions both in AND-group and the token. Introduced to for clarity.
    
    Parameters:
    
    token - Token to match
    
    Returns:
    
    True if matched.
  - setAndGroupElement
```
public void setAndGroupElement(PatternToken andToken)
```
  - hasAndGroup
```
public boolean hasAndGroup()
```
    Checks if this element has an AND group associated with it.
    
    Returns:
    
    true if the element has a group of elements that all should match.
  - getAndGroup
```
public List<PatternToken> getAndGroup()
```
    Returns the group of elements linked with AND operator.
  - setOrGroupElement
```
public void setOrGroupElement(PatternToken orToken)
```
    Since:
    
    2.3
  - hasOrGroup
```
public boolean hasOrGroup()
```
    Checks if this element has an OR group associated with it.
    
    Returns:
    
    true if the element has a group of elements that all should match.
    
    Since:
    
    2.3
  - getOrGroup
```
public List<PatternToken> getOrGroup()
```
    Returns the group of elements linked with OR operator.
    
    Since:
    
    2.3
  - isMatchedByScopeNextException
```
public boolean isMatchedByScopeNextException(AnalyzedToken token)
```
    Checks whether a previously set exception matches (in case the exception had scope == "next").
    
    Parameters:
    
    token - AnalyzedToken to check matching against.
    
    Returns:
    
    True if any of the exceptions matches.
  - isMatchedByPreviousException
```
public boolean isMatchedByPreviousException(AnalyzedToken token)
```
    Checks whether an exception for a previous token matches (in case the exception had scope == "previous").
    
    Parameters:
    
    token - AnalyzedToken to check matching against.
    
    Returns:
    
    True if any of the exceptions matches.
  - isMatchedByPreviousException
```
public boolean isMatchedByPreviousException(AnalyzedTokenReadings prevToken)
```
    Checks whether an exception for a previous token matches all readings of a given token (in case the exception had scope == "previous").
    
    Parameters:
    
    prevToken - AnalyzedTokenReadings to check matching against.
    
    Returns:
    
    true if any of the exceptions matches.
  - isSentenceStart
```
public boolean isSentenceStart()
```
    Checks if the token is a sentence start.
    
    Returns:
    
    True if the element starts the sentence and the element hasn't been set to have negated POS token.
  - setPosToken
```
public void setPosToken(PatternToken.PosToken posToken)
```
    Since:
    
    2.9
  - setChunkTag
```
public void setChunkTag(ChunkTag chunkTag)
```
    Since:
    
    2.9
  - getString
```
public String getString()
```
  - setStringElement
```
public void setStringElement(String token)
```
  - setStringPosException
```
public void setStringPosException(String token,
                                  boolean regExp,
                                  boolean inflected,
                                  boolean negation,
                                  boolean scopeNext,
                                  boolean scopePrevious,
                                  String posToken,
                                  boolean posRegExp,
                                  boolean posNegation,
                                  Boolean caseSensitivity)
```
    Sets a string and/or pos exception for matching tokens.
    
    Parameters:
    
    token - The string in the exception.
    
    regExp - True if the string is specified as a regular expression.
    
    inflected - True if the string is a base form (lemma).
    
    negation - True if the exception is negated.
    
    scopeNext - True if the exception scope is next tokens.
    
    scopePrevious - True if the exception should match only a single previous token.
    
    posToken - The part of the speech tag in the exception.
    
    posRegExp - True if the POS is specified as a regular expression.
    
    posNegation - True if the POS exception is negated.
    
    caseSensitivity - if null, use this element's setting for case sensitivity, otherwise the specified value
    
    Since:
    
    2.9
  - getSkipNext
```
public int getSkipNext()
```
    Gets the exception scope length.
    
    Returns:
    
    scope length in tokens
  - getMinOccurrence
```
public int getMinOccurrence()
```
    The minimum number of times the element needs to occur.
  - getMaxOccurrence
```
public int getMaxOccurrence()
```
    The maximum number of times the element may occur.
  - setSkipNext
```
public void setSkipNext(int i)
```
    Parameters:
    
    i - exception scope length.
  - setMinOccurrence
```
public void setMinOccurrence(int i)
```
    The minimum number of times this element may occur.
    
    Parameters:
    
    i - currently only 0 and 1 are supported
  - setMaxOccurrence
```
public void setMaxOccurrence(int i)
```
    The maximum number of times this element may occur.
    
    Parameters:
    
    i - a number >= 1 or -1 for unlimited occurrences
  - hasPreviousException
```
public boolean hasPreviousException()
```
    Checks if the element has an exception for a previous token.
    
    Returns:
    
    True if the element has a previous token matching exception.
  - hasNextException
```
public boolean hasNextException()
```
    Checks if the element has an exception for a next scope. (only used for testing)
    
    Returns:
    
    True if the element has exception for the next scope.
  - setNegation
```
public void setNegation(boolean negation)
```
    Negates the matching so that non-matching elements match and vice-versa.
  - getNegation
```
public boolean getNegation()
```
    see setNegation(boolean)
    
    Since:
    
    0.9.3
  - isReferenceElement
```
public boolean isReferenceElement()
```
    Returns:
    
    true when this element refers to another token.
  - setMatch
```
public void setMatch(Match match)
```
    Sets the reference to another token.
    
    Parameters:
    
    match - Formatting object for the token reference.
  - getMatch
```
public Match getMatch()
```
  - compile
```
public PatternToken compile(AnalyzedTokenReadings token,
                            Synthesizer synth)
                     throws IOException
```
    Prepare PatternToken for matching by formatting its string token and POS (if the Element is supposed to refer to some other token).
    
    Parameters:
    
    token - the token specified as AnalyzedTokenReadings
    
    synth - the language synthesizer (Synthesizer)
    
    Throws:
    
    IOException
  - setPhraseName
```
public void setPhraseName(String id)
```
    Sets the phrase the element is in.
    
    Parameters:
    
    id - ID of the phrase.
  - isPartOfPhrase
```
public boolean isPartOfPhrase()
```
    Checks if the Element is in any phrase.
    
    Returns:
    
    True if the Element is contained in the phrase.
  - isCaseSensitive
```
public boolean isCaseSensitive()
```
    Whether the element matches case sensitively.
    
    Since:
    
    2.3
  - isRegularExpression
```
public boolean isRegularExpression()
```
    Tests whether the element matches a regular expression.
    
    Since:
    
    0.9.6
  - isPOStagRegularExpression
```
public boolean isPOStagRegularExpression()
```
    Tests whether the POS matches a regular expression.
    
    Since:
    
    1.3.0
  - getPOStag
```
@Nullable
public String getPOStag()
```
    Returns:
    
    the POS of the Element or null
    
    Since:
    
    0.9.6
  - getChunkTag
```
@Nullable
public ChunkTag getChunkTag()
```
    Returns:
    
    the chunk tag of the Element or null
    
    Since:
    
    2.3
  - getPOSNegation
```
public boolean getPOSNegation()
```
    Returns:
    
    true if the POS is negated.
  - isInflected
```
public boolean isInflected()
```
    Returns:
    
    true if the token matches all inflected forms
  - getPhraseName
```
@Nullable
public String getPhraseName()
```
    Gets the phrase the element is in.
    
    Returns:
    
    String The name of the phrase.
  - isUnified
```
public boolean isUnified()
```
  - setUnification
```
public void setUnification(Map<String,List<String>> uniFeatures)
```
  - getUniFeatures
```
@Nullable
public Map<String,List<String>> getUniFeatures()
```
    Get unification features and types.
    
    Returns:
    
    A map from features to a list of types or null
    
    Since:
    
    1.0.1
  - setUniNegation
```
public void setUniNegation()
```
  - isUniNegated
```
public boolean isUniNegated()
```
  - isLastInUnification
```
public boolean isLastInUnification()
```
  - setLastInUnification
```
public void setLastInUnification()
```
  - isUnificationNeutral
```
public boolean isUnificationNeutral()
```
    Determines whether the element should be silently ignored during unification, and simply added.
    
    Returns:
    
    True when the element is not included in unifying.
    
    Since:
    
    2.5
  - setUnificationNeutral
```
public void setUnificationNeutral()
```
    Sets the element as ignored during unification.
    
    Since:
    
    2.5
  - setWhitespaceBefore
```
public void setWhitespaceBefore(boolean isWhite)
```
  - isInsideMarker
```
public boolean isInsideMarker()
```
  - setInsideMarker
```
public void setInsideMarker(boolean isInsideMarker)
```
  - setExceptionSpaceBefore
```
public void setExceptionSpaceBefore(boolean isWhite)
```
    Sets the attribute on the exception that determines matching of patterns that depends on whether there was a space before the token matching the exception or not. The same procedure is used for tokens that are valid for previous or current tokens.
    
    Parameters:
    
    isWhite - If true, the space before exception is required.
  - isWhitespaceBefore
```
public boolean isWhitespaceBefore(AnalyzedToken token)
```
  - getExceptionList
```
@NotNull
public List<PatternToken> getExceptionList()
```
    Returns:
    
    A List of Exceptions. Used for testing.
    
    Since:
    
    1.0.0
  - hasCurrentOrNextExceptions
```
@ApiStatus.Internal
public boolean hasCurrentOrNextExceptions()
```
  - hasExceptionList
```
public boolean hasExceptionList()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class PatternToken

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

UNKNOWN_TAG

Constructor Detail

PatternToken

Method Detail

clone

isMatched

isExceptionMatched

isAndExceptionGroupMatched

isExceptionMatchedCompletely

setAndGroupElement

hasAndGroup

getAndGroup

setOrGroupElement

hasOrGroup

getOrGroup

isMatchedByScopeNextException

isMatchedByPreviousException

isMatchedByPreviousException

isSentenceStart

setPosToken

setChunkTag

getString

setStringElement

setStringPosException

getSkipNext

getMinOccurrence

getMaxOccurrence

setSkipNext

setMinOccurrence

setMaxOccurrence

hasPreviousException

hasNextException

setNegation

getNegation

isReferenceElement

setMatch

getMatch

compile

setPhraseName

isPartOfPhrase

isCaseSensitive

isRegularExpression

isPOStagRegularExpression

getPOStag

getChunkTag

getPOSNegation

isInflected

getPhraseName

isUnified

setUnification

getUniFeatures

setUniNegation

isUniNegated

isLastInUnification

setLastInUnification

isUnificationNeutral

setUnificationNeutral

setWhitespaceBefore

isInsideMarker

setInsideMarker

setExceptionSpaceBefore

isWhitespaceBefore

getExceptionList

hasCurrentOrNextExceptions

hasExceptionList

toString