PatternToken (LanguageTool Style and Grammar Checker Core 3.0 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.

Author:

Daniel Naber

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

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()`
`List<PatternToken>`	`getPreviousExceptionList()`
`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`	`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`	`setOptionalException(String token, boolean regExp, boolean inflected, boolean negation, String posToken, boolean posRegExp, boolean posNegation)` Deprecated. will be removed as it hasn't been used (deprecated since 3.0)
`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)`
`boolean`	`testWhitespace()`
`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).
- Method Detail
  - clone
```
public Object clone()
             throws CloneNotSupportedException
```
    Overrides:
    
    clone in class Object
    
    Throws:
    
    CloneNotSupportedException
  - isMatched
```
public final 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 final 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 final 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 final 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 final void setAndGroupElement(PatternToken andToken)
```
  - hasAndGroup
```
public final 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 final List<PatternToken> getAndGroup()
```
    Returns the group of elements linked with AND operator.
  - setOrGroupElement
```
public final void setOrGroupElement(PatternToken orToken)
```
    Since:
    
    2.3
  - hasOrGroup
```
public final 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 final List<PatternToken> getOrGroup()
```
    Returns the group of elements linked with OR operator.
    
    Since:
    
    2.3
  - isMatchedByScopeNextException
```
public final 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 final 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 final 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 final 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 final void setPosToken(PatternToken.PosToken posToken)
```
    Since:
    
    2.9
  - setChunkTag
```
public final void setChunkTag(ChunkTag chunkTag)
```
    Since:
    
    2.9
  - getString
```
@Nullable
public final String getString()
```
  - setStringElement
```
public final void setStringElement(String token)
```
  - setStringPosException
```
public final 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
  - setOptionalException
```
public final void setOptionalException(String token,
                        boolean regExp,
                        boolean inflected,
                        boolean negation,
                        String posToken,
                        boolean posRegExp,
                        boolean posNegation)
```
    Deprecated. will be removed as it hasn't been used (deprecated since 3.0)
    
    Sets an exception for matching Optional 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.
    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.
    Since:
    
    2.5
  - getSkipNext
```
public final int getSkipNext()
```
    Gets the exception scope length.
    
    Returns:
    scope length in tokens
  - getMinOccurrence
```
public final int getMinOccurrence()
```
    The minimum number of times the element needs to occur.
  - getMaxOccurrence
```
public final int getMaxOccurrence()
```
    The maximum number of times the element may occur.
  - setSkipNext
```
public final void setSkipNext(int i)
```
    Parameters:
    i - exception scope length.
  - setMinOccurrence
```
public final void setMinOccurrence(int i)
```
    The minimum number of times this element may occur.
    
    Parameters:
    i - currently only 0 and 1 are supported
  - setMaxOccurrence
```
public final 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 final 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 final 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 final void setNegation(boolean negation)
```
    Negates the matching so that non-matching elements match and vice-versa.
  - getNegation
```
public final boolean getNegation()
```
    see setNegation(boolean)
    
    Since:
    
    0.9.3
  - isReferenceElement
```
public final boolean isReferenceElement()
```
    Returns:
    true when this element refers to another token.
  - setMatch
```
public final void setMatch(Match match)
```
    Sets the reference to another token.
    
    Parameters:
    match - Formatting object for the token reference.
  - getMatch
```
public final Match getMatch()
```
  - compile
```
public final 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 final void setPhraseName(String id)
```
    Sets the phrase the element is in.
    
    Parameters:
    id - ID of the phrase.
  - isPartOfPhrase
```
public final boolean isPartOfPhrase()
```
    Checks if the Element is in any phrase.
    
    Returns:
    True if the Element is contained in the phrase.
  - isCaseSensitive
```
public final boolean isCaseSensitive()
```
    Whether the element matches case sensitively.
    
    Since:
    
    2.3
  - isRegularExpression
```
public final boolean isRegularExpression()
```
    Tests whether the element matches a regular expression.
    
    Since:
    
    0.9.6
  - isPOStagRegularExpression
```
public final boolean isPOStagRegularExpression()
```
    Tests whether the POS matches a regular expression.
    
    Since:
    
    1.3.0
  - getPOStag
```
@Nullable
public final String getPOStag()
```
    Returns:
    the POS of the Element or null
    Since:
    
    0.9.6
  - getChunkTag
```
@Nullable
public final ChunkTag getChunkTag()
```
    Returns:
    the chunk tag of the Element or null
    Since:
    
    2.3
  - getPOSNegation
```
public final boolean getPOSNegation()
```
    Returns:
    true if the POS is negated.
  - isInflected
```
public final boolean isInflected()
```
    Returns:
    true if the token matches all inflected forms
  - getPhraseName
```
@Nullable
public final String getPhraseName()
```
    Gets the phrase the element is in.
    
    Returns:
    String The name of the phrase.
  - isUnified
```
public final boolean isUnified()
```
  - setUnification
```
public final void setUnification(Map<String,List<String>> uniFeatures)
```
  - getUniFeatures
```
@Nullable
public final 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 final void setUniNegation()
```
  - isUniNegated
```
public final boolean isUniNegated()
```
  - isLastInUnification
```
public final boolean isLastInUnification()
```
  - setLastInUnification
```
public final 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 final void setWhitespaceBefore(boolean isWhite)
```
  - isInsideMarker
```
public boolean isInsideMarker()
```
  - setInsideMarker
```
public void setInsideMarker(boolean isInsideMarker)
```
  - setExceptionSpaceBefore
```
public final 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 final boolean isWhitespaceBefore(AnalyzedToken token)
```
  - getExceptionList
```
public final List<PatternToken> getExceptionList()
```
    Returns:
    A List of Exceptions. Used for testing.
    Since:
    
    1.0.0
  - getPreviousExceptionList
```
public final List<PatternToken> getPreviousExceptionList()
```
    Returns:
    List of previous exceptions. Used for testing.
  - hasExceptionList
```
public final boolean hasExceptionList()
```
  - testWhitespace
```
public final boolean testWhitespace()
```
  - toString
```
public final 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

setOptionalException

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

getPreviousExceptionList

hasExceptionList

testWhitespace

toString