AnalyzedTokenReadings (LanguageTool 6.4-SNAPSHOT API)

java.lang.Object
- org.languagetool.AnalyzedTokenReadings

All Implemented Interfaces:

Iterable<AnalyzedToken>
```
public final class AnalyzedTokenReadings
extends Object
implements Iterable<AnalyzedToken>
```
An array of AnalyzedTokens used to store multiple POS tags and lemmas for a given single token.

Author:

Marcin Milkowski

Constructor Summary

Constructors
Constructor and Description
`AnalyzedTokenReadings(AnalyzedToken token)`
`AnalyzedTokenReadings(AnalyzedToken[] tokens, int startPos)`
`AnalyzedTokenReadings(AnalyzedToken token, int startPos)`
`AnalyzedTokenReadings(AnalyzedTokenReadings oldAtr, List<AnalyzedToken> newReadings, String ruleApplied)`
`AnalyzedTokenReadings(List<AnalyzedToken> tokens, int startPos)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addReading(AnalyzedToken token, String ruleApplied)` Add a new reading.
`boolean`	`equals(Object obj)`
`AnalyzedToken`	`getAnalyzedToken(int idx)` Get a token reading.
`List<ChunkTag>`	`getChunkTags()`
`String`	`getCleanToken()`
`int`	`getEndPos()`
`String`	`getHistoricalAnnotations()` Used to track disambiguator actions.
`int`	`getImmunizationSourceLine()`
`int`	`getPosFix()`
`List<AnalyzedToken>`	`getReadings()`
`int`	`getReadingsLength()` Number of readings.
`int`	`getStartPos()`
`String`	`getToken()`
`String`	`getWhitespaceBefore()`
`boolean`	`hasAnyLemma(String... lemmas)` Checks if one of the token's readings has one of the given lemmas
`boolean`	`hasAnyPartialPosTag(String... posTags)` Checks if the token has any of the given particular POS tags (only a part of the given POS tag needs to match)
`int`	`hashCode()`
`boolean`	`hasLemma(String lemma)` Checks if one of the token's readings has a particular lemma.
`boolean`	`hasPartialPosTag(String posTag)` Checks if the token has a particular POS tag, where only a part of the given POS tag needs to match.
`boolean`	`hasPosTag(String posTag)` Checks if the token has a particular POS tag.
`boolean`	`hasPosTagAndLemma(String posTag, String lemma)` Checks if the token has a particular POS tag and lemma.
`boolean`	`hasPosTagStartingWith(String posTag)` Checks if the token has a POS tag starting with the given string.
`boolean`	`hasReading()` Checks if there is at least one POS tag
`boolean`	`hasSameLemmas()` Used to optimize pattern matching.
`boolean`	`hasTypographicApostrophe()`
`void`	`ignoreSpelling()` Make the token ignored by all spelling rules.
`void`	`immunize(int sourceLine)`
`boolean`	`isFieldCode()`
`boolean`	`isIgnoredBySpeller()` Test if the token can be ignored by spelling rules.
`boolean`	`isImmunized()`
`boolean`	`isLinebreak()` Returns true if the token equals `\n`, `\r`, `\n\r`, or `\r\n`.
`boolean`	`isNonWord()`
`boolean`	`isParagraphEnd()`
`boolean`	`isPosTagUnknown()` Test if the token's POStag equals null.
`boolean`	`isSentenceEnd()`
`boolean`	`isSentenceStart()`
`boolean`	`isTagged()`
`boolean`	`isWhitespace()`
`boolean`	`isWhitespaceBefore()`
`Iterator<AnalyzedToken>`	`iterator()`
`void`	`leaveReading(AnalyzedToken token)` Removes all readings but the one that matches the token given.
`boolean`	`matchesChunkRegex(String chunkRegex)`
`boolean`	`matchesPosTagRegex(String posTagRegex)` Checks if at least one of the readings matches a given POS tag regex.
`AnalyzedToken`	`readingWithLemma(String lemma)` Returns the first reading that matches a given lemma.
`AnalyzedToken`	`readingWithTagRegex(String posTagRegex)` Returns the first reading that matches a given POS tag regex.
`void`	`removeReading(AnalyzedToken token, String ruleApplied)` Removes a reading from the list of readings.
`void`	`setChunkTags(List<ChunkTag> chunkTags)`
`void`	`setCleanToken(String cleanToken)`
`void`	`setParagraphEnd()` Add a reading with a paragraph end token unless this is already a paragraph end.
`void`	`setPosFix(int fix)`
`void`	`setSentEnd()` Add a SENT_END tag.
`void`	`setStartPos(int position)`
`void`	`setTypographicApostrophe()`
`void`	`setWhitespaceBefore(String prevToken)`
`String`	`toString()`

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - AnalyzedTokenReadings
```
public AnalyzedTokenReadings(AnalyzedToken[] tokens,
                             int startPos)
```
  - AnalyzedTokenReadings
```
public AnalyzedTokenReadings(AnalyzedToken token,
                             int startPos)
```
  - AnalyzedTokenReadings
```
public AnalyzedTokenReadings(List<AnalyzedToken> tokens,
                             int startPos)
```
  - AnalyzedTokenReadings
```
public AnalyzedTokenReadings(AnalyzedTokenReadings oldAtr,
                             List<AnalyzedToken> newReadings,
                             String ruleApplied)
```
  - AnalyzedTokenReadings
```
public AnalyzedTokenReadings(AnalyzedToken token)
```
- Method Detail
  - getReadings
```
public List<AnalyzedToken> getReadings()
```
  - getAnalyzedToken
```
public AnalyzedToken getAnalyzedToken(int idx)
```
    Get a token reading.
    
    See Also:
    
    getReadingsLength() for how many token readings there are
  - hasPosTag
```
public boolean hasPosTag(String posTag)
```
    Checks if the token has a particular POS tag.
    
    Parameters:
    
    posTag - POS tag to look for
  - hasPosTagAndLemma
```
public boolean hasPosTagAndLemma(String posTag,
                                 String lemma)
```
    Checks if the token has a particular POS tag and lemma.
    
    Parameters:
    
    posTag - POS tag and lemma to look for
  - hasReading
```
public boolean hasReading()
```
    Checks if there is at least one POS tag
    
    Since:
    
    4.7
  - hasLemma
```
public boolean hasLemma(String lemma)
```
    Checks if one of the token's readings has a particular lemma.
    
    Parameters:
    
    lemma - lemma POS tag to look for
  - hasAnyLemma
```
public boolean hasAnyLemma(String... lemmas)
```
    Checks if one of the token's readings has one of the given lemmas
    
    Parameters:
    
    lemmas - lemmas to look for
  - hasPartialPosTag
```
public boolean hasPartialPosTag(String posTag)
```
    Checks if the token has a particular POS tag, where only a part of the given POS tag needs to match.
    
    Parameters:
    
    posTag - POS tag substring to look for
    
    Since:
    
    1.8
  - hasAnyPartialPosTag
```
public boolean hasAnyPartialPosTag(String... posTags)
```
    Checks if the token has any of the given particular POS tags (only a part of the given POS tag needs to match)
    
    Parameters:
    
    posTags - POS tag substring to look for
    
    Since:
    
    4.0
  - hasPosTagStartingWith
```
public boolean hasPosTagStartingWith(String posTag)
```
    Checks if the token has a POS tag starting with the given string.
    
    Parameters:
    
    posTag - POS tag substring to look for
    
    Since:
    
    4.0
  - matchesPosTagRegex
```
public boolean matchesPosTagRegex(String posTagRegex)
```
    Checks if at least one of the readings matches a given POS tag regex.
    
    Parameters:
    
    posTagRegex - POS tag regular expression to look for
    
    Since:
    
    2.9
  - matchesChunkRegex
```
public boolean matchesChunkRegex(String chunkRegex)
```
  - readingWithTagRegex
```
public AnalyzedToken readingWithTagRegex(String posTagRegex)
```
    Returns the first reading that matches a given POS tag regex.
    
    Parameters:
    
    posTagRegex - POS tag regular expression to look for
    
    Since:
    
    5.5
  - readingWithLemma
```
public AnalyzedToken readingWithLemma(String lemma)
```
    Returns the first reading that matches a given lemma.
    
    Since:
    
    5.8
  - addReading
```
public void addReading(AnalyzedToken token,
                       String ruleApplied)
```
    Add a new reading.
    
    Parameters:
    
    token - new reading, given as AnalyzedToken
  - removeReading
```
public void removeReading(AnalyzedToken token,
                          String ruleApplied)
```
    Removes a reading from the list of readings. Note: if the token has only one reading, then a new reading with an empty POS tag and an empty lemma is created.
    
    Parameters:
    
    token - reading to be removed
  - leaveReading
```
public void leaveReading(AnalyzedToken token)
```
    Removes all readings but the one that matches the token given.
    
    Parameters:
    
    token - Token to be matched
    
    Since:
    
    1.5
  - getReadingsLength
```
public int getReadingsLength()
```
    Number of readings.
  - isWhitespace
```
public boolean isWhitespace()
```
  - isLinebreak
```
public boolean isLinebreak()
```
    Returns true if the token equals \n, \r, \n\r, or \r\n.
  - isSentenceStart
```
public boolean isSentenceStart()
```
    Since:
    
    2.3
  - isParagraphEnd
```
public boolean isParagraphEnd()
```
    Returns:
    
    true when the token is a last token in a paragraph.
    
    Since:
    
    2.3
  - setParagraphEnd
```
public void setParagraphEnd()
```
    Add a reading with a paragraph end token unless this is already a paragraph end.
    
    Since:
    
    2.3
  - isSentenceEnd
```
public boolean isSentenceEnd()
```
    Returns:
    
    true when the token is a last token in a sentence.
    
    Since:
    
    2.3
  - isFieldCode
```
public boolean isFieldCode()
```
    Returns:
    
    true if the token is LibreOffice/OpenOffice field code.
    
    Since:
    
    0.9.9
  - setSentEnd
```
public void setSentEnd()
```
    Add a SENT_END tag.
  - getStartPos
```
public int getStartPos()
```
  - getEndPos
```
public int getEndPos()
```
    Since:
    
    2.9
  - setStartPos
```
public void setStartPos(int position)
```
  - setPosFix
```
public void setPosFix(int fix)
```
    Since:
    
    5.1
  - getPosFix
```
public int getPosFix()
```
    Since:
    
    5.1
  - getToken
```
public String getToken()
```
  - setWhitespaceBefore
```
public void setWhitespaceBefore(String prevToken)
```
  - getWhitespaceBefore
```
public String getWhitespaceBefore()
```
  - isWhitespaceBefore
```
public boolean isWhitespaceBefore()
```
  - immunize
```
public void immunize(int sourceLine)
```
  - isImmunized
```
public boolean isImmunized()
```
  - getImmunizationSourceLine
```
public int getImmunizationSourceLine()
```
  - ignoreSpelling
```
public void ignoreSpelling()
```
    Make the token ignored by all spelling rules.
    
    Since:
    
    2.5
  - isIgnoredBySpeller
```
public boolean isIgnoredBySpeller()
```
    Test if the token can be ignored by spelling rules.
    
    Returns:
    
    true if the token should be ignored.
    
    Since:
    
    2.5
  - isPosTagUnknown
```
public boolean isPosTagUnknown()
```
    Test if the token's POStag equals null.
    
    Returns:
    
    true if the token does not have a POStag
    
    Since:
    
    3.9
  - getHistoricalAnnotations
```
public String getHistoricalAnnotations()
```
    Used to track disambiguator actions.
    
    Returns:
    
    the historicalAnnotations
  - setChunkTags
```
public void setChunkTags(List<ChunkTag> chunkTags)
```
    Since:
    
    2.3
  - getChunkTags
```
public List<ChunkTag> getChunkTags()
```
    Since:
    
    2.3
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - isTagged
```
public boolean isTagged()
```
    Returns:
    
    true if AnalyzedTokenReadings has some real POS tag (= not null or a special tag)
    
    Since:
    
    2.3
  - hasSameLemmas
```
public boolean hasSameLemmas()
```
    Used to optimize pattern matching.
    
    Returns:
    
    true if all AnalyzedToken lemmas are the same.
  - isNonWord
```
public boolean isNonWord()
```
    Returns:
    
    true if AnalyzedTokenReadings is a punctuation mark, bracket, etc
    
    Since:
    
    4.4
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - iterator
```
@NotNull
public Iterator<AnalyzedToken> iterator()
```
    Specified by:
    
    iterator in interface Iterable<AnalyzedToken>
    
    Since:
    
    2.3
  - setCleanToken
```
@Experimental
public void setCleanToken(String cleanToken)
```
    Since:
    
    5.1
  - getCleanToken
```
@Experimental
public String getCleanToken()
```
    Since:
    
    5.1
  - setTypographicApostrophe
```
public void setTypographicApostrophe()
```
    Since:
    
    5.2
  - hasTypographicApostrophe
```
public boolean hasTypographicApostrophe()
```
    Since:
    
    5.2

Class AnalyzedTokenReadings

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

AnalyzedTokenReadings

AnalyzedTokenReadings

AnalyzedTokenReadings

AnalyzedTokenReadings

AnalyzedTokenReadings

Method Detail

getReadings

getAnalyzedToken

hasPosTag

hasPosTagAndLemma

hasReading

hasLemma

hasAnyLemma

hasPartialPosTag

hasAnyPartialPosTag

hasPosTagStartingWith

matchesPosTagRegex

matchesChunkRegex

readingWithTagRegex

readingWithLemma

addReading

removeReading

leaveReading

getReadingsLength

isWhitespace

isLinebreak

isSentenceStart

isParagraphEnd

setParagraphEnd

isSentenceEnd

isFieldCode

setSentEnd

getStartPos

getEndPos

setStartPos

setPosFix

getPosFix

getToken

setWhitespaceBefore

getWhitespaceBefore

isWhitespaceBefore

immunize

isImmunized

getImmunizationSourceLine

ignoreSpelling

isIgnoredBySpeller

isPosTagUnknown

getHistoricalAnnotations

setChunkTags

getChunkTags

toString

isTagged

hasSameLemmas

isNonWord

hashCode

equals

iterator

setCleanToken

getCleanToken

setTypographicApostrophe

hasTypographicApostrophe