Uses of Class
org.languagetool.AnalyzedTokenReadings

Packages that use AnalyzedTokenReadings

Package	Description
org.languagetool
org.languagetool.chunking
org.languagetool.noop
org.languagetool.rules
org.languagetool.rules.ar
org.languagetool.rules.ar.filters
org.languagetool.rules.br
org.languagetool.rules.ca
org.languagetool.rules.de
org.languagetool.rules.el
org.languagetool.rules.en
org.languagetool.rules.es
org.languagetool.rules.fa
org.languagetool.rules.fr
org.languagetool.rules.ga
org.languagetool.rules.it
org.languagetool.rules.km
org.languagetool.rules.nl
org.languagetool.rules.patterns
org.languagetool.rules.pl
org.languagetool.rules.pt
org.languagetool.rules.ro
org.languagetool.rules.ru
org.languagetool.rules.spelling
org.languagetool.rules.spelling.morfologik
org.languagetool.rules.spelling.multitoken
org.languagetool.rules.uk
org.languagetool.server
org.languagetool.tagging
org.languagetool.tagging.ar
org.languagetool.tagging.br
org.languagetool.tagging.ca
org.languagetool.tagging.de
org.languagetool.tagging.disambiguation
org.languagetool.tagging.disambiguation.rules
org.languagetool.tagging.disambiguation.uk
org.languagetool.tagging.en
org.languagetool.tagging.eo
org.languagetool.tagging.es
org.languagetool.tagging.fr
org.languagetool.tagging.ga
org.languagetool.tagging.gl
org.languagetool.tagging.ja
org.languagetool.tagging.nl
org.languagetool.tagging.pl
org.languagetool.tagging.pt
org.languagetool.tagging.ru
org.languagetool.tagging.uk
org.languagetool.tagging.xx
org.languagetool.tagging.zh

Uses of AnalyzedTokenReadings in org.languagetool

Fields in org.languagetool declared as AnalyzedTokenReadings

Modifier and Type	Field	Description
private final AnalyzedTokenReadings[]	AnalyzedSentence.nonBlankPreDisambigTokens
private final AnalyzedTokenReadings[]	AnalyzedSentence.nonBlankTokens
private final AnalyzedTokenReadings[]	AnalyzedSentence.preDisambigTokens
private final AnalyzedTokenReadings[]	AnalyzedSentence.tokens

Methods in org.languagetool that return AnalyzedTokenReadings

Modifier and Type	Method	Description
AnalyzedTokenReadings[]	AnalyzedSentence.getPreDisambigTokens()
AnalyzedTokenReadings[]	AnalyzedSentence.getPreDisambigTokensWithoutWhitespace()
AnalyzedTokenReadings[]	AnalyzedSentence.getTokens()	Returns the AnalyzedTokenReadings of the analyzed text.
AnalyzedTokenReadings[]	AnalyzedSentence.getTokensWithoutWhitespace()	Returns the AnalyzedTokenReadings of the analyzed text, with whitespace tokens removed but with the artificial SENT_START token included.

Methods in org.languagetool that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private List<AnalyzedTokenReadings>	AnalyzedSentence.getNonBlankReadings(AnalyzedTokenReadings[] tokens, int whCounter, int nonWhCounter, int[] mapping)

Methods in org.languagetool with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private List<AnalyzedTokenReadings>	AnalyzedSentence.getNonBlankReadings(AnalyzedTokenReadings[] tokens, int whCounter, int nonWhCounter, int[] mapping)
private static Map<String,List<Integer>>	AnalyzedSentence.indexLemmas(AnalyzedTokenReadings[] tokens)
private static Map<String,List<Integer>>	AnalyzedSentence.indexTokens(AnalyzedTokenReadings[] tokens)

Constructors in org.languagetool with parameters of type AnalyzedTokenReadings

Modifier	Constructor	Description
	AnalyzedSentence(AnalyzedTokenReadings[] tokens)	Creates an AnalyzedSentence from the given AnalyzedTokenReadings.
private	AnalyzedSentence(AnalyzedTokenReadings[] tokens, int[] mapping, AnalyzedTokenReadings[] nonBlankTokens, AnalyzedTokenReadings[] nonBlankPreDisambigTokens)
	AnalyzedSentence(AnalyzedTokenReadings[] tokens, AnalyzedTokenReadings[] preDisambigTokens)
	AnalyzedTokenReadings(AnalyzedTokenReadings oldAtr, List<AnalyzedToken> newReadings, String ruleApplied)

Uses of AnalyzedTokenReadings in org.languagetool.chunking

Fields in org.languagetool.chunking declared as AnalyzedTokenReadings

Modifier and Type	Field	Description
private final AnalyzedTokenReadings	ChunkTaggedToken.readings

Methods in org.languagetool.chunking that return AnalyzedTokenReadings

Modifier and Type	Method	Description
private AnalyzedTokenReadings	EnglishChunker.getAnalyzedTokenReadingsFor(int startPos, int endPos, List<AnalyzedTokenReadings> tokenReadings)
AnalyzedTokenReadings	ChunkTaggedToken.getReadings()

Method parameters in org.languagetool.chunking with type arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
void	Chunker.addChunkTags(List<AnalyzedTokenReadings> sentenceTokenReadings)
void	EnglishChunker.addChunkTags(List<AnalyzedTokenReadings> tokenReadings)
void	GermanChunker.addChunkTags(List<AnalyzedTokenReadings> tokenReadings)
void	RussianChunker.addChunkTags(List<AnalyzedTokenReadings> tokenReadings)
private static Set<String>	GermanChunker.allForms(List<AnalyzedTokenReadings> tokens)
private AnalyzedTokenReadings	EnglishChunker.getAnalyzedTokenReadingsFor(int startPos, int endPos, List<AnalyzedTokenReadings> tokenReadings)
(package private) List<ChunkTaggedToken>	GermanChunker.getBasicChunks(List<AnalyzedTokenReadings> tokenReadings)
private List<ChunkTaggedToken>	GermanChunker.getBasicChunks(List<AnalyzedTokenReadings> tokenReadings, Set<String> allForms)
(package private) List<ChunkTaggedToken>	RussianChunker.getBasicChunks(List<AnalyzedTokenReadings> tokenReadings)
private List<ChunkTaggedToken>	EnglishChunker.getChunkTagsForReadings(List<AnalyzedTokenReadings> tokenReadings)
private String	EnglishChunker.getSentence(List<AnalyzedTokenReadings> sentenceTokens)
private List<ChunkTaggedToken>	EnglishChunker.getTokensWithTokenReadings(List<AnalyzedTokenReadings> tokenReadings, String[] tokens, String[] chunkTags)

Constructors in org.languagetool.chunking with parameters of type AnalyzedTokenReadings

Modifier	Constructor	Description
	ChunkTaggedToken(String token, List<ChunkTag> chunkTags, AnalyzedTokenReadings readings)

Uses of AnalyzedTokenReadings in org.languagetool.noop

Method parameters in org.languagetool.noop with type arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
void	NoopChunker.addChunkTags(List<AnalyzedTokenReadings> tokenReadings)

Uses of AnalyzedTokenReadings in org.languagetool.rules

Methods in org.languagetool.rules that return AnalyzedTokenReadings

Modifier and Type	Method	Description
protected abstract AnalyzedTokenReadings	AbstractStatisticSentenceStyleRule.conditionFulfilled(List<AnalyzedTokenReadings> tokens)	Condition to generate a hint (possibly including all exceptions) Returns: < nAnalysedToken, if condition is not fulfilled >= nAnalysedToken, if condition is not fulfilled; integer is number of token which is the end hint
static AnalyzedTokenReadings	GRPCUtils.fromGRPC(MLServerProto.AnalyzedTokenReadings tokenReadings)
private AnalyzedTokenReadings	PunctuationMarkAtParagraphEnd2.getLastNonSpaceToken(AnalyzedTokenReadings[] tokens)

Methods in org.languagetool.rules that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private Map<String,AnalyzedTokenReadings>	AbstractCompoundRule.getStringToTokenMap(Queue<AnalyzedTokenReadings> prevTokens, List<String> stringsToCheck, List<String> origStringsToCheck)
protected abstract List<AnalyzedTokenReadings>	PartialPosTagFilter.tag(String token)

Methods in org.languagetool.rules with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	AbstractAdvancedSynthesizerFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractDateCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractDateCheckWithSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractFindSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractFutureDateFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractMakeContractionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractNewYearDateFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractNumberInWordFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractSuppressMisspelledSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AbstractTextToNumberFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AdaptSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AddCommasFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	CheckPostagsInSuggestionFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ConvertToSentenceCaseFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	DateRangeChecker.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	IsEnglishWordFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PartialPosTagFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ShortenedYearRangeChecker.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	SuppressIfAnyRuleMatchesFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	UnderlineSpacesFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	WhitespaceCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
private static void	AbstractCompoundRule.addToQueue(AnalyzedTokenReadings token, ArrayDeque<AnalyzedTokenReadings> prevTokens)
protected int	AbstractFillerWordsRule.conditionFulfilled(AnalyzedTokenReadings[] tokens, int nAnalysedToken)
protected abstract int	AbstractStatisticStyleRule.conditionFulfilled(AnalyzedTokenReadings[] tokens, int nAnalysedToken)	Condition to generate a hint (possibly including all exceptions) Returns: < nAnalysedToken, if condition is not fulfilled >= nAnalysedToken, if condition is not fulfilled; integer is number of token which is the end hint
private void	AbstractSimpleReplaceRule2.createMatch(List<RuleMatch> ruleMatches, SuggestionWithMessage suggestionWithMessage, int startIndex, int endIndex, String originalStr, AnalyzedTokenReadings[] tokens, AnalyzedSentence sentence, int sentStart, int[] checkCaseCoveredUpto)
protected String	AbstractWordCoherencyRule.createReplacement(String marked, String token, String otherSpelling, AnalyzedTokenReadings tmpToken)
protected RuleMatch	AbstractSimpleReplaceRule.createRuleMatch(AnalyzedTokenReadings tokenReadings, List<String> replacements, AnalyzedSentence sentence, String originalTokenStr)
private String	UppercaseSentenceStartRule.dutchSpecialCase(String firstToken, String secondToken, AnalyzedTokenReadings[] tokens)
private boolean	GenericUnpairedBracketsRule.fillSymbolStack(int startPosBase, AnalyzedTokenReadings[] tokens, int i, int j, UnsyncStack<SymbolLocator> symbolStack, AnalyzedSentence sentence, int sentenceIdx)
protected List<RuleMatch>	AbstractSimpleReplaceRule.findMatches(AnalyzedTokenReadings tokenReadings, AnalyzedSentence sentence)
private AnalyzedToken	AbstractAdvancedSynthesizerFilter.getAnalyzedToken(AnalyzedTokenReadings aToken, String regexp)
private AnalyzedTokenReadings	PunctuationMarkAtParagraphEnd2.getLastNonSpaceToken(AnalyzedTokenReadings[] tokens)
protected String	AbstractStyleTooOftenUsedWordRule.getLemmaForPosTagStartsWith(String startPos, AnalyzedTokenReadings token)
private boolean	GenericUnpairedBracketsRule.getPrecededByWhitespace(AnalyzedTokenReadings[] tokens, int i, int j)
private boolean	GenericUnpairedBracketsRule.getSpecialCase(AnalyzedTokenReadings[] tokens, int i, int j)
protected abstract List<String>	AbstractFindSuggestionsFilter.getSpellingSuggestions(AnalyzedTokenReadings atr)
protected List<String>	WordRepeatBeginningRule.getSuggestions(AnalyzedTokenReadings analyzedToken)
private static boolean	AbstractStyleRepeatedWordRule.hasBreakToken(AnalyzedTokenReadings[] tokens)
boolean	WordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)	Implement this method to return true if there's a potential word repetition at the current position that should be ignored, i.e.
protected boolean	WordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)
boolean	ParagraphRepeatBeginningRule.isArticle(AnalyzedTokenReadings token)
private boolean	GenericUnpairedQuotesRule.isClosingQuote(AnalyzedTokenReadings[] tokens, int i, List<GenericUnpairedQuotesRule.SymbolLocator> openingQuotes)
private boolean	CommaWhitespaceRule.isDomain(AnalyzedTokenReadings[] tokens, int i)	Case Insensitive check if the token at index i is a valid domain name (e.g.
protected boolean	AbstractFillerWordsRule.isException(AnalyzedTokenReadings[] tokens, int num)
protected abstract boolean	AbstractRepeatedWordsRule.isException(AnalyzedTokenReadings[] tokens, int i, boolean sentStart, boolean isCapitalized, boolean isAllUppercase)
protected abstract boolean	AbstractStyleTooOftenUsedWordRule.isException(AnalyzedTokenReadings[] tokens, int n)	An exception is defined for the token
protected boolean	CommaWhitespaceRule.isException(AnalyzedTokenReadings[] tokens, int tokenIdx)
protected boolean	UppercaseSentenceStartRule.isException(AnalyzedTokenReadings[] tokens, int tokenIdx)
protected boolean	AbstractStyleRepeatedWordRule.isExceptionPair(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2)
private boolean	CommaWhitespaceRule.isFileExtension(AnalyzedTokenReadings[] tokens, int i)
private static boolean	MultipleWhitespaceRule.isFirstWhite(AnalyzedTokenReadings token)
private boolean	AbstractStyleRepeatedWordRule.isInQuotes(AnalyzedTokenReadings[] tokens, int i)
protected boolean	AbstractStatisticSentenceStyleRule.isMark(AnalyzedTokenReadings token)
protected boolean	GenericUnpairedBracketsRule.isNoException(String token, AnalyzedTokenReadings[] tokens, int i, int j, boolean precSpace, boolean follSpace, UnsyncStack<SymbolLocator> symbolStack)	Generic method to specify an exception.
protected boolean	GenericUnpairedQuotesRule.isNotBeginningApostrophe(AnalyzedTokenReadings[] tokens, int i)
protected boolean	GenericUnpairedQuotesRule.isNotEndingApostrophe(AnalyzedTokenReadings[] tokens, int i)
private boolean	GenericUnpairedQuotesRule.isNotQuote(AnalyzedTokenReadings[] tokens, int i, int j)
protected boolean	AbstractStatisticSentenceStyleRule.isOpeningQuote(AnalyzedTokenReadings token)
private boolean	GenericUnpairedQuotesRule.isOpeningQuote(AnalyzedTokenReadings[] tokens, int i)
protected abstract boolean	AbstractTextToNumberFilter.isPercentage(AnalyzedTokenReadings[] patternTokens, int i)
private static boolean	PunctuationMarkAtParagraphEnd.isPunctuationMark(AnalyzedTokenReadings tk)
private static boolean	PunctuationMarkAtParagraphEnd.isQuotationMark(AnalyzedTokenReadings tk)
private static boolean	MultipleWhitespaceRule.isRemovableWhite(AnalyzedTokenReadings token)
private boolean	GenericUnpairedQuotesRule.isStartSymbolbefore(AnalyzedTokenReadings[] tokens, int i)
protected boolean	AbstractFindSuggestionsFilter.isSuggestionException(AnalyzedTokenReadings analyzedSuggestion)
protected boolean	AbstractSimpleReplaceRule.isTagged(AnalyzedTokenReadings tokenReadings)	This method allows to override which tags will mark token as tagged
protected abstract boolean	AbstractStyleTooOftenUsedWordRule.isToCountedWord(AnalyzedTokenReadings token)	A token that has to be counted
protected boolean	AbstractSimpleReplaceRule.isTokenException(AnalyzedTokenReadings atr)
protected boolean	AbstractSimpleReplaceRule2.isTokenException(AnalyzedTokenReadings atr)
private boolean	AbstractStyleRepeatedWordRule.isTokenInSentence(AnalyzedTokenReadings testToken, AnalyzedTokenReadings[] tokens, boolean isDirectSpeech)
private boolean	AbstractStyleRepeatedWordRule.isTokenInSentence(AnalyzedTokenReadings testToken, AnalyzedTokenReadings[] tokens, int notCheck, boolean isDirectSpeech)
protected abstract boolean	AbstractStyleRepeatedWordRule.isTokenPair(AnalyzedTokenReadings[] tokens, int n, boolean before)
protected abstract boolean	AbstractStyleRepeatedWordRule.isTokenToCheck(AnalyzedTokenReadings token)
private boolean	WhiteSpaceAtBeginOfParagraph.isWhitespaceDel(AnalyzedTokenReadings token)
private static boolean	CommaWhitespaceRule.isWhitespaceToken(AnalyzedTokenReadings token)
private static boolean	PunctuationMarkAtParagraphEnd.isWord(AnalyzedTokenReadings tk)
private String	ConvertToSentenceCaseFilter.normalizedCase(AnalyzedTokenReadings atr)
private int	ParagraphRepeatBeginningRule.numCharEqualBeginning(AnalyzedTokenReadings[] lastTokens, AnalyzedTokenReadings[] nextTokens)
protected boolean	AbstractFillerWordsRule.sentenceConditionFulfilled(AnalyzedTokenReadings[] tokens, int nAnalysedToken)
protected abstract boolean	AbstractStatisticStyleRule.sentenceConditionFulfilled(AnalyzedTokenReadings[] tokens, int nAnalysedToken)	Condition to generate a hint related to the sentence (possibly including all exceptions)
protected URL	AbstractStyleRepeatedWordRule.setURL(AnalyzedTokenReadings token)
protected abstract String	AbstractStyleTooOftenUsedWordRule.toAddedLemma(AnalyzedTokenReadings token)	Gives back the lemma that should be added to the word map
static MLServerProto.AnalyzedTokenReadings	GRPCUtils.toGRPC(AnalyzedTokenReadings readings)
protected boolean	WordRepeatRule.wordRepetitionOf(String word, AnalyzedTokenReadings[] tokens, int position)

Method parameters in org.languagetool.rules with type arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private static void	AbstractCompoundRule.addToQueue(AnalyzedTokenReadings token, ArrayDeque<AnalyzedTokenReadings> prevTokens)
protected abstract AnalyzedTokenReadings	AbstractStatisticSentenceStyleRule.conditionFulfilled(List<AnalyzedTokenReadings> tokens)	Condition to generate a hint (possibly including all exceptions) Returns: < nAnalysedToken, if condition is not fulfilled >= nAnalysedToken, if condition is not fulfilled; integer is number of token which is the end hint
private Map<String,AnalyzedTokenReadings>	AbstractCompoundRule.getStringToTokenMap(Queue<AnalyzedTokenReadings> prevTokens, List<String> stringsToCheck, List<String> origStringsToCheck)
private boolean	PartialPosTagFilter.partialTagHasRequiredTag(List<AnalyzedTokenReadings> tags, String requiredTagRegexp, boolean negatePos)

Uses of AnalyzedTokenReadings in org.languagetool.rules.ar

Methods in org.languagetool.rules.ar with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private String	ArabicTransVerbRule.generateAttachedNewForm(String prepositionLemma, AnalyzedTokenReadings prevtoken)
private String	ArabicTransVerbRule.generateUnattachedNewForm(AnalyzedTokenReadings token)
private String	ArabicTransVerbRule.getCorrectPrepositionForm(String prepositionLemma, AnalyzedTokenReadings prevtoken)
private String	ArabicTransVerbRule.getCorrectVerbForm(AnalyzedTokenReadings token)
private List<String>	ArabicTransVerbRule.getProperPrepositionForTransitiveVerb(AnalyzedTokenReadings mytoken)
boolean	ArabicWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
private boolean	ArabicTransVerbRule.isAttachedTransitiveVerb(AnalyzedTokenReadings mytoken)
private static boolean	ArabicTransVerbRule.isRightPreposition(AnalyzedTokenReadings nextToken, List<String> prepositionList)

Uses of AnalyzedTokenReadings in org.languagetool.rules.ar.filters

Methods in org.languagetool.rules.ar.filters with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	ArabicAdjectiveToExclamationFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ArabicDMYDateCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ArabicMasdarToVerbFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ArabicNumberPhraseFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ArabicVerbToMafoulMutlaqFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
private static boolean	ArabicNumberPhraseFilter.getFemininCase(AnalyzedTokenReadings[] patternTokens, int nextPos)
private static String	ArabicNumberPhraseFilter.getInflectedCase(AnalyzedTokenReadings[] patternTokens, int previousPos, String inflect)
private List<String>	ArabicNumberPhraseFilter.inflectUnit(AnalyzedTokenReadings unit, Map<String,String> sugMap)
static List<String>	ArabicNumberPhraseFilter.prepareSuggestion(String numPhrase, String previousWord, AnalyzedTokenReadings nextWord, boolean feminin, boolean attached, String inflection)
List<String>	ArabicNumberPhraseFilter.prepareSuggestionWithUnits(String numPhrase, String previousWord, AnalyzedTokenReadings nextWord, boolean feminin, boolean attached, String inflection)

Uses of AnalyzedTokenReadings in org.languagetool.rules.br

Methods in org.languagetool.rules.br with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private void	TopoReplaceRule.addToQueue(AnalyzedTokenReadings token, Queue<AnalyzedTokenReadings> prevTokens)

Method parameters in org.languagetool.rules.br with type arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private void	TopoReplaceRule.addToQueue(AnalyzedTokenReadings token, Queue<AnalyzedTokenReadings> prevTokens)

Uses of AnalyzedTokenReadings in org.languagetool.rules.ca

Fields in org.languagetool.rules.ca with type parameters of type AnalyzedTokenReadings

Modifier and Type	Field	Description
private static final Map<String,AnalyzedTokenReadings>	DiacriticsCheckFilter.relevantWords

Methods in org.languagetool.rules.ca that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
(package private) Map<String,AnalyzedTokenReadings>	ConfusionPairsDataLoader.loadWords(String path)

Methods in org.languagetool.rules.ca with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	AdjustPronounsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AdjustVerbSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	AnarASuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	CatalanNumberSpellerFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ConvertToGenderAndNumberFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	DiacriticsCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	DonarTempsSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	FindSuggestionsEsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	OblidarseSugestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PortarGerundiSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PortarTempsSuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PossessiusRedundantsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PostponedAdjectiveConcordanceFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	SynthesizeWithDeterminerFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
protected String	WordCoherencyRule.createReplacement(String marked, String token, String otherSpelling, AnalyzedTokenReadings atrs)
protected String	WordCoherencyValencianRule.createReplacement(String marked, String token, String otherSpelling, AnalyzedTokenReadings atrs)
private AnalyzedToken	PostponedAdjectiveConcordanceFilter.getAnalyzedToken(AnalyzedTokenReadings aToken, Pattern pattern)
private String	PronomFebleDuplicateRule.getLemmaOfPronomFeble(AnalyzedTokenReadings aToken)
static String[]	PronomsFeblesHelper.getPreviousPronouns(AnalyzedTokenReadings[] tokens, int toIndex)
private AnalyzedToken	ConvertToGenderAndNumberFilter.getReadingWithPriority(AnalyzedTokenReadings token)
protected List<String>	FindSuggestionsFilter.getSpellingSuggestions(AnalyzedTokenReadings atr)
private String	PronomFebleDuplicateRule.getSuggestionFromTo(AnalyzedTokenReadings[] tokens, int from, int to)
protected List<String>	CatalanWordRepeatBeginningRule.getSuggestions(AnalyzedTokenReadings token)
static String[]	PronomsFeblesHelper.getTwoNextPronouns(AnalyzedTokenReadings[] tokens, int from)
private int	CatalanUnpairedQuestionMarksRule.hasTokenAtPos(String ch, AnalyzedTokenReadings[] tokens)
boolean	CatalanWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
protected boolean	CatalanWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)
protected boolean	CatalanRepeatedWordsRule.isException(AnalyzedTokenReadings[] tokens, int i, boolean sentStart, boolean isCapitalized, boolean isAllUppercase)
private boolean	PronomFebleDuplicateRule.isException(AnalyzedTokenReadings[] tokens, int i)
protected boolean	CatalanUnpairedBracketsRule.isNoException(String tokenStr, AnalyzedTokenReadings[] tokens, int i, int j, boolean precSpace, boolean follSpace, UnsyncStack<SymbolLocator> symbolStack)
protected boolean	TextToNumberFilter.isPercentage(AnalyzedTokenReadings[] patternTokens, int i)
protected boolean	FindSuggestionsFilter.isSuggestionException(AnalyzedTokenReadings analyzedSuggestion)
private boolean	PronomFebleDuplicateRule.isThereErrorInLemmas(List<String> lemesPronomsAbans, List<String> lemesPronomsDespres, List<String> lemesPreposicions, AnalyzedTokenReadings[] tokens, int lastVerbPos)
protected boolean	SimpleReplaceAnglicism.isTokenException(AnalyzedTokenReadings atr)
protected boolean	SimpleReplaceBalearicRule.isTokenException(AnalyzedTokenReadings atr)
protected boolean	SimpleReplaceDiacriticsIEC.isTokenException(AnalyzedTokenReadings atr)
private boolean	PostponedAdjectiveConcordanceFilter.keepCounting(AnalyzedTokenReadings aTr)
private boolean	MorfologikCatalanSpellerRule.matchPostagRegexp(AnalyzedTokenReadings aToken, Pattern pattern)	Match POS tag with regular expression
private boolean	PostponedAdjectiveConcordanceFilter.matchPostagRegexp(AnalyzedTokenReadings aToken, Pattern pattern)	Match POS tag with regular expression
private boolean	ReplaceOperationNamesRule.matchPostagRegexp(AnalyzedTokenReadings aToken, Pattern pattern)	Match POS tag with regular expression
private void	PostponedAdjectiveConcordanceFilter.updateApparitions(AnalyzedTokenReadings aTr)
private int	PostponedAdjectiveConcordanceFilter.updateJValue(AnalyzedTokenReadings[] tokens, int i, int j, int level)

Uses of AnalyzedTokenReadings in org.languagetool.rules.de

Fields in org.languagetool.rules.de declared as AnalyzedTokenReadings

Modifier and Type	Field	Description
private final AnalyzedTokenReadings	AgreementSuggestor2.adjToken1
private final AnalyzedTokenReadings	AgreementSuggestor2.adjToken2
private final AnalyzedTokenReadings	AgreementSuggestor2.determinerToken
(package private) AnalyzedTokenReadings	VerbAgreementRule.BooleanAndFiniteVerb.finiteVerb
private final AnalyzedTokenReadings	AgreementSuggestor2.nounToken
private AnalyzedTokenReadings	AgreementSuggestor2.prepositionToken

Methods in org.languagetool.rules.de that return AnalyzedTokenReadings

Modifier and Type	Method	Description
protected AnalyzedTokenReadings	ConjunctionAtBeginOfSentenceRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is sentence with modal verb
protected AnalyzedTokenReadings	PassiveSentenceRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is passive sentence
protected AnalyzedTokenReadings	SentenceWithManRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is sentence with verb man
protected AnalyzedTokenReadings	SentenceWithModalVerbRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is sentence with modal verb
private AnalyzedTokenReadings	CaseRule.lookup(String word)

Methods in org.languagetool.rules.de that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private static List<AnalyzedTokenReadings>	InsertCommaFilter.getTag(int i, String[] parts)

Methods in org.languagetool.rules.de with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	AdaptSuggestionFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	CompoundCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	InsertCommaFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PotentialCompoundFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	RecentYearFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	RemoveUnknownCompoundsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	UppercaseNounReadingFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	ValidWordFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	YMDDateCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	YMDNewYearDateFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
private void	CaseRule.addRuleMatch(List<RuleMatch> ruleMatches, AnalyzedSentence sentence, String msg, AnalyzedTokenReadings tokenReadings, String fixedWord)
private boolean	AgreementRule.agreementWithCategoryRelaxation(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AgreementRule.GrammarCategory categoryToRelax)
private RuleMatch	AgreementRule2.checkAdjNounAgreement(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedSentence sentence)
private RuleMatch	AgreementRule.checkDetAdjAdjNounAgreement(AnalyzedTokenReadings maybePreposition, AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedTokenReadings token3, AnalyzedTokenReadings token4, AnalyzedSentence sentence, int tokenPos, Map<Integer,AgreementRule.ReplacementType> replMap, String skippedStr)
private RuleMatch	AgreementRule.checkDetAdjNounAgreement(AnalyzedTokenReadings maybePreposition, AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedTokenReadings token3, AnalyzedSentence sentence, int tokenPos, Map<Integer,AgreementRule.ReplacementType> replMap, String skippedStr)
private RuleMatch	AgreementRule.checkDetNounAgreement(AnalyzedTokenReadings maybePreposition, AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedSentence sentence, int tokenPos, Map<Integer,AgreementRule.ReplacementType> replMap, String skippedStr)
(package private) static boolean	CaseRule.compareLists(AnalyzedTokenReadings[] tokens, int startIndex, int endIndex, StringMatcher... patterns)
protected int	GermanFillerWordsRule.conditionFulfilled(AnalyzedTokenReadings[] tokens, int nToken)
protected int	NonSignificantVerbsRule.conditionFulfilled(AnalyzedTokenReadings[] tokens, int nAnalysedToken)
protected int	UnnecessaryPhraseRule.conditionFulfilled(AnalyzedTokenReadings[] tokens, int nAnalysedToken)
private boolean	SubjectVerbAgreementRule.containsOnlyInfinitivesToTheLeft(AnalyzedTokenReadings[] tokens, int startPos)
private boolean	SubjectVerbAgreementRule.containsRegexToTheLeft(String regex, AnalyzedTokenReadings[] tokens, int startPos)
private boolean	AgreementRule.couldBeRelativeOrDependentClause(AnalyzedTokenReadings[] tokens, int pos)
private static String	UnnecessaryPhraseRule.firstCharToLower(AnalyzedTokenReadings[] tokens, int nToken)	changes first char to upper as sentence begin
private boolean	CaseRule.followedByGenderGap(AnalyzedTokenReadings[] tokens, int i)
(package private) List<String>	AdaptSuggestionFilter.getAdaptedDet(AnalyzedTokenReadings detToken, String repl)
(package private) List<String>	AdaptSuggestionFilter.getAdaptedDetAdj(AnalyzedTokenReadings detToken, AnalyzedTokenReadings adjToken, String repl)
private String[]	AgreementSuggestor2.getAdjSynth(String num, String gen, String aCase, AnalyzedTokenReadings adjToken, AnalyzedToken detReading)
private Set<String>	AgreementRule.getAgreementCategories(AnalyzedTokenReadings aToken)
(package private) static Set<String>	AgreementTools.getAgreementCategories(AnalyzedTokenReadings aToken, Set<AgreementRule.GrammarCategory> omit, boolean skipSol)	Return Kasus, Numerus, Genus of those forms with a determiner.
(package private) static Set<String>	AgreementTools.getAgreementSOLCategories(AnalyzedTokenReadings aToken, Set<AgreementRule.GrammarCategory> omit)
private String	AdaptSuggestionFilter.getBaseform(AnalyzedTokenReadings token, String tagStartsWith)
(package private) List<String>	AgreementRule.getCategoriesCausingError(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2)
private static int	MissingCommaRelativeClauseRule.getCommaBehind(AnalyzedTokenReadings[] tokens, List<Integer> verbs, int start, int end)	gives back position where a comma is missed
private RuleMatch	AgreementRule.getCompoundError(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, int tokenPos, AnalyzedSentence sentence)
private RuleMatch	AgreementRule.getCompoundError(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedTokenReadings token3, int tokenPos, AnalyzedSentence sentence)
private RuleMatch	AgreementRule.getCompoundError(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedTokenReadings token3, AnalyzedTokenReadings token4, int tokenPos, AnalyzedSentence sentence, String skippedStr)
private static String	MissingCommaRelativeClauseRule.getGender(AnalyzedTokenReadings token)	get the gender of of a token
private String	CompoundCoherencyRule.getLemma(AnalyzedTokenReadings atr)
private String	CompoundInfinitivRule.getLemma(AnalyzedTokenReadings token)
private int	ProhibitedCompoundRule.getMatches(AnalyzedSentence sentence, List<RuleMatch> ruleMatches, AnalyzedTokenReadings readings, int partsStartPos, String wordPart, int toPosCorrection)
private RuleMatch	SubjectVerbAgreementRule.getPluralMatchOrNull(AnalyzedTokenReadings[] tokens, int i, AnalyzedTokenReadings token, String tokenStr, AnalyzedSentence sentence)
private int	AgreementRule.getPosAfterModifier(int startAt, AnalyzedTokenReadings[] tokens)	Search for modifiers (such as "sehr", "1,4 Meter") which can expand a determiner - adjective - noun group ("ein hohes Haus" -> "ein sehr hohes Haus", "ein 500 Meter hohes Haus") and return the index of the first non-modifier token ("Haus")
private List<String>	VerbAgreementRule.getPronounSuggestions(AnalyzedTokenReadings verb, boolean toUppercase)
private RuleMatch	AgreementRule.getRuleMatch(AnalyzedTokenReadings token, AnalyzedTokenReadings token2, AnalyzedSentence sentence, String testPhrase, String hyphenTestPhrase)
private RuleMatch	SubjectVerbAgreementRule.getSingularMatchOrNull(AnalyzedTokenReadings[] tokens, int i, AnalyzedTokenReadings token, String tokenStr, AnalyzedSentence sentence)
private static String	MissingCommaRelativeClauseRule.getSinOrPluOfPro(AnalyzedTokenReadings token)	checks if personal pronoun is singular or plural gives back null if token is not a personal pronoun
private List<String>	AgreementRule2.getSuggestions(AnalyzedTokenReadings[] tokens, int i)
private int	CaseRule.getTokensWithPosTagStartingWithCount(AnalyzedTokenReadings[] tokens, String partialPosTag)
private List<String>	VerbAgreementRule.getVerbSuggestions(AnalyzedTokenReadings verb, String expectedVerbPOS, boolean toUppercase)
private boolean	CaseRule.hasNounReading(AnalyzedTokenReadings readings)
private boolean	CaseRule.hasPartialTag(AnalyzedTokenReadings token, String... posTags)
private int	RedundantModalOrAuxiliaryVerb.hasParticipleAt(int nConjunction, int nStart, AnalyzedTokenReadings[] tokens)
private static int	MissingCommaRelativeClauseRule.hasPotentialSubclause(AnalyzedTokenReadings[] tokens, int start, int end)	checks to what position a test of relative clause should done return -1 if no potential relative clause is assumed
private boolean	SubjectVerbAgreementRule.hasQuestionPronounToTheLeft(AnalyzedTokenReadings[] tokens, int startPos)
static boolean	GermanHelper.hasReadingOfType(AnalyzedTokenReadings tokenReadings, GermanToken.POSType type)
private boolean	VerbAgreementRule.hasUnambiguouslyPersonAndNumber(AnalyzedTokenReadings tokenReadings, String person, String number)
private boolean	SubjectVerbAgreementRule.hasUnknownTokenAt(AnalyzedTokenReadings[] tokens, int startPos, int endPos)
private boolean	SubjectVerbAgreementRule.hasUnknownTokenToTheLeft(AnalyzedTokenReadings[] tokens, int startPos)
private boolean	SubjectVerbAgreementRule.hasUnknownTokenToTheRight(AnalyzedTokenReadings[] tokens, int startPos)
private boolean	SubjectVerbAgreementRule.hasVerbToTheLeft(AnalyzedTokenReadings[] tokens, int startPos)
boolean	GermanWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
private boolean	CaseRule.isAdjectiveAsNoun(int i, AnalyzedTokenReadings[] tokens, AnalyzedTokenReadings lowercaseReadings)
protected boolean	GermanWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)
private boolean	CaseRule.isAdverbAndNominalization(int i, AnalyzedTokenReadings[] tokens)
private static boolean	MissingCommaRelativeClauseRule.isAnyVerb(AnalyzedTokenReadings[] tokens, int n)	is any verb but not an "Infinitiv mit zu"
boolean	GermanParagraphRepeatBeginningRule.isArticle(AnalyzedTokenReadings token)
private static boolean	MissingCommaRelativeClauseRule.isArticle(String gender, AnalyzedTokenReadings[] tokens, int from, int to)	check if token is potentially an article
private static boolean	MissingCommaRelativeClauseRule.isArticleWithoutSub(String gender, AnalyzedTokenReadings[] tokens, int n)	is the token a potential article without a noun
private static boolean	ConjunctionAtBeginOfSentenceRule.isComma(AnalyzedTokenReadings token)	Token is comma
private static boolean	ConjunctionAtBeginOfSentenceRule.isConjunction(AnalyzedTokenReadings token)	Word is a Conjunction
private boolean	SubjectVerbAgreementRule.isCurrency(AnalyzedTokenReadings token)
private boolean	CaseRule.isEllipsis(int i, AnalyzedTokenReadings[] tokens)
private boolean	AgreementRule.isException(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2)
private boolean	CompoundInfinitivRule.isException(AnalyzedTokenReadings[] tokens, int n)
protected boolean	GermanCommaWhitespaceRule.isException(AnalyzedTokenReadings[] tokens, int tokenIdx)
private static boolean	GermanFillerWordsRule.isException(AnalyzedTokenReadings[] tokens, int num)
protected boolean	GermanRepeatedWordsRule.isException(AnalyzedTokenReadings[] tokens, int i, boolean sentStart, boolean isCapitalized, boolean isAllUppercase)
private static boolean	NonSignificantVerbsRule.isException(AnalyzedTokenReadings[] tokens, int num)
protected boolean	StyleTooOftenUsedAdjectiveRule.isException(AnalyzedTokenReadings[] tokens, int n)
protected boolean	StyleTooOftenUsedNounRule.isException(AnalyzedTokenReadings[] tokens, int n)
protected boolean	StyleTooOftenUsedVerbRule.isException(AnalyzedTokenReadings[] tokens, int n)
private static boolean	UnnecessaryPhraseRule.isException(AnalyzedTokenReadings[] tokens, String[] phrase)
protected boolean	GermanStyleRepeatedWordRule.isExceptionPair(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2)
private boolean	CaseRule.isExceptionPhrase(int i, AnalyzedTokenReadings[] tokens)
private boolean	VerbAgreementRule.isFiniteVerb(AnalyzedTokenReadings token)
(package private) boolean	SubjectVerbAgreementRule.isFollowedByNominativePlural(AnalyzedTokenReadings[] tokens, int startPos)
private boolean	CaseRule.isFollowedByRelativeOrSubordinateClause(int i, AnalyzedTokenReadings[] tokens)
private static boolean	MissingCommaRelativeClauseRule.isFourCombinedVerbs(AnalyzedTokenReadings[] tokens, int first, int last)	is a special combination of four verbs combination
private static boolean	CompoundInfinitivRule.isInfinitiv(AnalyzedTokenReadings token)
private static boolean	MissingCommaRelativeClauseRule.isInfinitivZu(AnalyzedTokenReadings[] tokens, int last)	is participle plus special combination of two verbs combination
private boolean	CaseRule.isInvisibleSeparator(int i, AnalyzedTokenReadings[] tokens)
private static boolean	MissingCommaRelativeClauseRule.isKonAfterVerb(AnalyzedTokenReadings[] tokens, int start, int end)	conjunction follows last verb
private static boolean	MissingCommaRelativeClauseRule.isKonUnt(AnalyzedTokenReadings token)	first token initiate a subclause
private boolean	CaseRule.isLanguage(int i, AnalyzedTokenReadings[] tokens, String token)
private static boolean	SentenceWithModalVerbRule.isModalVerb(AnalyzedTokenReadings token)	Word is a modal verb
private boolean	CaseRule.isNominalization(int i, AnalyzedTokenReadings[] tokens, String token, AnalyzedTokenReadings lowercaseReadings)
private boolean	AgreementRule.isNonPredicativeAdjective(AnalyzedTokenReadings tokensReadings)
private boolean	CaseRule.isNounWithVerbReading(int i, AnalyzedTokenReadings[] tokens)
private boolean	CaseRule.isNumbering(int i, AnalyzedTokenReadings[] tokens)
private static boolean	MissingCommaRelativeClauseRule.isPar(AnalyzedTokenReadings token)	is participle
private boolean	AgreementRule.isParticiple(AnalyzedTokenReadings tokensReadings)
private static boolean	MissingCommaRelativeClauseRule.isPerfect(AnalyzedTokenReadings[] tokens, int first, int second)	is a pair of verbs to build the perfect
private static boolean	MissingCommaRelativeClauseRule.isPerfect(AnalyzedTokenReadings[] tokens, int first, int second, int third)	is a pair of verbs to build the perfect
private boolean	CaseRule.isPotentialUpperCaseError(int pos, AnalyzedTokenReadings[] tokens, AnalyzedTokenReadings lowercaseReadings, boolean isPrecededByModalOrAuxiliary)
private boolean	CaseRule.isPrevProbablyRelativePronoun(AnalyzedTokenReadings[] tokens, int i)
private boolean	CaseRule.isProbablyCity(int i, AnalyzedTokenReadings[] tokens, String token)
private static boolean	MissingCommaRelativeClauseRule.isPronoun(AnalyzedTokenReadings[] tokens, int n)	is potential relative pronoun
private static boolean	MissingCommaRelativeClauseRule.isPrp(AnalyzedTokenReadings token)	is preposition
private boolean	VerbAgreementRule.isQuotationMark(AnalyzedTokenReadings token)
private boolean	CompoundInfinitivRule.isRelevant(AnalyzedTokenReadings token)
private boolean	AgreementRule.isRelevantPronoun(AnalyzedTokenReadings[] tokens, int pos)
private static boolean	MissingCommaRelativeClauseRule.isSeparatorOrInf(AnalyzedTokenReadings[] tokens, int n)	is separator or VER:INF
private boolean	CaseRule.isSingularImperative(AnalyzedTokenReadings lowercaseReadings, AnalyzedTokenReadings token)
private boolean	CaseRule.isSpecialCase(int i, AnalyzedTokenReadings[] tokens)
private static boolean	MissingCommaRelativeClauseRule.isSpecialInf(AnalyzedTokenReadings[] tokens, int first, int second, int start)	is Infinitive in combination with substantiv
private static boolean	MissingCommaRelativeClauseRule.isSpecialPair(AnalyzedTokenReadings[] tokens, int first, int second)	two infinitive verbs as pair
private static boolean	MissingCommaRelativeClauseRule.isThreeCombinedVerbs(AnalyzedTokenReadings[] tokens, int first, int last)	is a special combination of three verbs combination
protected boolean	StyleTooOftenUsedAdjectiveRule.isToCountedWord(AnalyzedTokenReadings token)
protected boolean	StyleTooOftenUsedNounRule.isToCountedWord(AnalyzedTokenReadings token)
protected boolean	StyleTooOftenUsedVerbRule.isToCountedWord(AnalyzedTokenReadings token)
protected boolean	GermanStyleRepeatedWordRule.isTokenPair(AnalyzedTokenReadings[] tokens, int n, boolean before)	Pairs of substantive are excluded like "Arm in Arm", "Seite an Seite", etc.
protected boolean	GermanStyleRepeatedWordRule.isTokenToCheck(AnalyzedTokenReadings token)	Only substantive, names, verbs and adjectives are checked
private static boolean	MissingCommaRelativeClauseRule.isTwoCombinedVerbs(AnalyzedTokenReadings first, AnalyzedTokenReadings second)	is a special combination of two verbs combination
private static boolean	MissingCommaRelativeClauseRule.isTwoPlusCombinedVerbs(AnalyzedTokenReadings[] tokens, int first, int last)	is verb plus special combination of two verbs combination
private static boolean	GermanStyleRepeatedWordRule.isUnknownWord(AnalyzedTokenReadings token)	Is a unknown word (has only letters and no PosTag)
private static boolean	NonSignificantVerbsRule.isUnknownWord(AnalyzedTokenReadings token)
private static boolean	MissingCommaRelativeClauseRule.isVerb(AnalyzedTokenReadings[] tokens, int n)	is a potential verb used in sentence or subclause
(package private) static boolean	MissingCommaRelativeClauseRule.isVerbBehind(AnalyzedTokenReadings[] tokens, int end)	is a verb after sub clause
private boolean	CaseRule.isVerbFollowing(int i, AnalyzedTokenReadings[] tokens, AnalyzedTokenReadings lowercaseReadings)
private static boolean	MissingCommaRelativeClauseRule.isVerbProPair(AnalyzedTokenReadings[] tokens, int n)
private static boolean	SentenceWithManRule.isWordMan(AnalyzedTokenReadings token)	Word is 'man'
private static boolean	MissingCommaRelativeClauseRule.matchesGender(String gender, AnalyzedTokenReadings[] tokens, int from, int to)	does the gender match with a subject or name?
private static int	MissingCommaRelativeClauseRule.missedCommaBehind(AnalyzedTokenReadings[] tokens, int inFront, int start, int end)	gives back position where a comma is missed PRP has to be treated separately
private static int	MissingCommaRelativeClauseRule.missedCommaInFront(AnalyzedTokenReadings[] tokens, int start, int end, int lastVerb)	gives back position where a comma is missed PRP has to be treated separately
private boolean	VerbAgreementRule.nextButOneIsModal(AnalyzedTokenReadings[] tokens, int pos)
private static int	MissingCommaRelativeClauseRule.nextSeparator(AnalyzedTokenReadings[] tokens, int start)	get the position of the next separator
private static boolean	AgreementTools.possessiveSpecialCase(AnalyzedTokenReadings aToken, AnalyzedToken tmpReading)
private void	CaseRule.potentiallyAddLowercaseMatch(List<RuleMatch> ruleMatches, AnalyzedTokenReadings tokenReadings, boolean prevTokenIsDas, String token, boolean nextTokenIsPersonalOrReflexivePronoun, AnalyzedSentence sentence)
private void	CaseRule.potentiallyAddUppercaseMatch(List<RuleMatch> ruleMatches, AnalyzedTokenReadings[] tokens, int i, AnalyzedTokenReadings analyzedToken, String token, AnalyzedTokenReadings lowercaseReadings, AnalyzedSentence sentence)
(package private) boolean	SubjectVerbAgreementRule.prevChunkIsNominative(AnalyzedTokenReadings[] tokens, int startPos)
private Map<Integer,AgreementRule.ReplacementType>	AgreementRule.replacePrepositionsByArticle(AnalyzedTokenReadings[] tokens)
private Set<String>	AgreementRule.retainCommonCategories(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedTokenReadings token3)
private Set<String>	AgreementRule.retainCommonCategories(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, AnalyzedTokenReadings token3, AnalyzedTokenReadings token4)
private Set<String>	AgreementRule2.retainCommonCategories(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2)
private RuleMatch	VerbAgreementRule.ruleMatchWrongVerb(AnalyzedTokenReadings token, int pos, AnalyzedSentence sentence)
private RuleMatch	VerbAgreementRule.ruleMatchWrongVerbSubject(AnalyzedTokenReadings subject, AnalyzedTokenReadings verb, String expectedVerbPOS, int pos, AnalyzedSentence sentence)
protected boolean	GermanFillerWordsRule.sentenceConditionFulfilled(AnalyzedTokenReadings[] tokens, int nToken)
protected boolean	NonSignificantVerbsRule.sentenceConditionFulfilled(AnalyzedTokenReadings[] tokens, int nToken)
protected boolean	UnnecessaryPhraseRule.sentenceConditionFulfilled(AnalyzedTokenReadings[] tokens, int nToken)
(package private) void	AgreementSuggestor2.setPreposition(AnalyzedTokenReadings prep)
protected URL	GermanStyleRepeatedWordRule.setURL(AnalyzedTokenReadings token)
private static int	MissingCommaRelativeClauseRule.skipSub(AnalyzedTokenReadings[] tokens, int n, int to)	skip tokens till the next noun check for e.g.
private static int	MissingCommaRelativeClauseRule.skipToSub(String gender, AnalyzedTokenReadings[] tokens, int n, int to)	skip tokens till the next noun check for e.g.
protected String	StyleTooOftenUsedAdjectiveRule.toAddedLemma(AnalyzedTokenReadings token)
protected String	StyleTooOftenUsedNounRule.toAddedLemma(AnalyzedTokenReadings token)
protected String	StyleTooOftenUsedVerbRule.toAddedLemma(AnalyzedTokenReadings token)
private boolean	MissingVerbRule.verbAtSentenceStart(AnalyzedTokenReadings readings)
private VerbAgreementRule.BooleanAndFiniteVerb	VerbAgreementRule.verbDoesMatchPersonAndNumber(AnalyzedTokenReadings token1, AnalyzedTokenReadings token2, String person, String number, AnalyzedTokenReadings finiteVerb)
private static List<Integer>	MissingCommaRelativeClauseRule.verbPos(AnalyzedTokenReadings[] tokens, int start, int end)	gives the positions of verbs in a subclause

Method parameters in org.languagetool.rules.de with type arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected AnalyzedTokenReadings	ConjunctionAtBeginOfSentenceRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is sentence with modal verb
protected AnalyzedTokenReadings	PassiveSentenceRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is passive sentence
protected AnalyzedTokenReadings	SentenceWithManRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is sentence with verb man
protected AnalyzedTokenReadings	SentenceWithModalVerbRule.conditionFulfilled(List<AnalyzedTokenReadings> sentence)	Is sentence with modal verb
private boolean	InsertCommaFilter.hasTag(List<AnalyzedTokenReadings> tags, String tagStart)

Constructors in org.languagetool.rules.de with parameters of type AnalyzedTokenReadings

Modifier	Constructor	Description
(package private)	AgreementSuggestor2(Synthesizer synthesizer, AnalyzedTokenReadings determinerToken, AnalyzedTokenReadings adjToken1, AnalyzedTokenReadings adjToken2, AnalyzedTokenReadings nounToken, AgreementRule.ReplacementType replacementType)
(package private)	AgreementSuggestor2(Synthesizer synthesizer, AnalyzedTokenReadings determinerToken, AnalyzedTokenReadings adjToken1, AnalyzedTokenReadings nounToken, AgreementRule.ReplacementType replacementType)
(package private)	AgreementSuggestor2(Synthesizer synthesizer, AnalyzedTokenReadings determinerToken, AnalyzedTokenReadings nounToken, AgreementRule.ReplacementType replacementType)
private	BooleanAndFiniteVerb(boolean verbDoesMatchPersonAndNumber, AnalyzedTokenReadings finiteVerb)

Uses of AnalyzedTokenReadings in org.languagetool.rules.el

Methods in org.languagetool.rules.el with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected List<String>	GreekWordRepeatBeginningRule.getSuggestions(AnalyzedTokenReadings token)
protected boolean	GreekWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)

Uses of AnalyzedTokenReadings in org.languagetool.rules.en

Methods in org.languagetool.rules.en that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected List<AnalyzedTokenReadings>	EnglishPartialPosTagFilter.tag(String token)
protected List<AnalyzedTokenReadings>	NoDisambiguationEnglishPartialPosTagFilter.tag(String token)

Methods in org.languagetool.rules.en with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	AdverbFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	OrdinalSuffixFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	YMDDateCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	YMDNewYearDateFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
(package private) boolean	UpperCaseNgramRule.firstLongWordToLeftIsUppercase(AnalyzedTokenReadings[] tokens, int pos)
(package private) boolean	UpperCaseNgramRule.firstLongWordToRightIsUppercase(AnalyzedTokenReadings[] tokens, int pos)
(package private) static AvsAnRule.Determiner	AvsAnRule.getCorrectDeterminerFor(AnalyzedTokenReadings token)
protected List<RuleMatch>	AbstractEnglishSpellerRule.getRuleMatches(String word, int startPos, AnalyzedSentence sentence, List<RuleMatch> ruleMatchesSoFar, int idx, AnalyzedTokenReadings[] tokens)
protected List<String>	FindSuggestionsFilter.getSpellingSuggestions(AnalyzedTokenReadings atr)
protected List<String>	EnglishWordRepeatBeginningRule.getSuggestions(AnalyzedTokenReadings token)
boolean	EnglishWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
protected boolean	EnglishWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)
protected boolean	EnglishRepeatedWordsRule.isException(AnalyzedTokenReadings[] tokens, int i, boolean sentStart, boolean isCapitalized, boolean isAllUppercase)
protected boolean	StyleTooOftenUsedAdjectiveRule.isException(AnalyzedTokenReadings[] tokens, int n)
protected boolean	StyleTooOftenUsedNounRule.isException(AnalyzedTokenReadings[] tokens, int n)
protected boolean	StyleTooOftenUsedVerbRule.isException(AnalyzedTokenReadings[] tokens, int n)
protected boolean	EnglishUnpairedQuotesRule.isNotBeginningApostrophe(AnalyzedTokenReadings[] tokens, int i)
protected boolean	EnglishUnpairedQuotesRule.isNotEndingApostrophe(AnalyzedTokenReadings[] tokens, int i)
private boolean	UpperCaseNgramRule.isSentence(AnalyzedTokenReadings[] tokens)
private boolean	UpperCaseNgramRule.isShortWord(AnalyzedTokenReadings token)
protected boolean	StyleTooOftenUsedAdjectiveRule.isToCountedWord(AnalyzedTokenReadings token)
protected boolean	StyleTooOftenUsedNounRule.isToCountedWord(AnalyzedTokenReadings token)
protected boolean	StyleTooOftenUsedVerbRule.isToCountedWord(AnalyzedTokenReadings token)
(package private) boolean	UpperCaseNgramRule.maybeTitle(AnalyzedTokenReadings[] tokens, int i)
private boolean	UpperCaseNgramRule.nextIsOneOfThenUppercase(AnalyzedTokenReadings[] tokens, int i, List<String> strings)
private boolean	UpperCaseNgramRule.nextIsUpperCase(AnalyzedTokenReadings[] tokens, int i)
private boolean	EnglishWordRepeatRule.posIsIn(AnalyzedTokenReadings[] tokens, int position, String... posTags)
private boolean	UpperCaseNgramRule.prevIsOneOf(AnalyzedTokenReadings[] tokens, int i, List<String> strings)
private boolean	UpperCaseNgramRule.prevIsUpperCase(AnalyzedTokenReadings[] tokens, int i)
private boolean	EnglishWordRepeatRule.repetitionOf(String word, AnalyzedTokenReadings[] tokens, int position)
protected String	StyleTooOftenUsedAdjectiveRule.toAddedLemma(AnalyzedTokenReadings token)
protected String	StyleTooOftenUsedNounRule.toAddedLemma(AnalyzedTokenReadings token)
protected String	StyleTooOftenUsedVerbRule.toAddedLemma(AnalyzedTokenReadings token)
private boolean	UpperCaseNgramRule.trieMatches(String text, AnalyzedTokenReadings token)

Uses of AnalyzedTokenReadings in org.languagetool.rules.es

Fields in org.languagetool.rules.es with type parameters of type AnalyzedTokenReadings

Modifier and Type	Field	Description
private static final Map<String,AnalyzedTokenReadings>	ConfusionCheckFilter.relevantWords

Methods in org.languagetool.rules.es that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
(package private) Map<String,AnalyzedTokenReadings>	ConfusionPairsDataLoader.loadWords(String path)

Methods in org.languagetool.rules.es with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	ConfusionCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PostponedAdjectiveConcordanceFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
private AnalyzedToken	PostponedAdjectiveConcordanceFilter.getAnalyzedToken(AnalyzedTokenReadings aToken, Pattern pattern)
protected List<String>	FindSuggestionsFilter.getSpellingSuggestions(AnalyzedTokenReadings atr)
protected List<String>	SpanishWordRepeatBeginningRule.getSuggestions(AnalyzedTokenReadings token)
private int	QuestionMarkRule.hasTokenAtPos(String ch, AnalyzedTokenReadings[] tokens)
boolean	SpanishWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
protected boolean	SpanishWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)
protected boolean	SpanishRepeatedWordsRule.isException(AnalyzedTokenReadings[] tokens, int i, boolean sentStart, boolean isCapitalized, boolean isAllUppercase)
protected boolean	SpanishUnpairedBracketsRule.isNoException(String tokenStr, AnalyzedTokenReadings[] tokens, int i, int j, boolean precSpace, boolean follSpace, UnsyncStack<SymbolLocator> symbolStack)
protected boolean	TextToNumberFilter.isPercentage(AnalyzedTokenReadings[] patternTokens, int i)
private boolean	PostponedAdjectiveConcordanceFilter.keepCounting(AnalyzedTokenReadings aTr)
private boolean	PostponedAdjectiveConcordanceFilter.matchPostagRegexp(AnalyzedTokenReadings aToken, Pattern pattern)	Match POS tag with regular expression
private void	PostponedAdjectiveConcordanceFilter.updateApparitions(AnalyzedTokenReadings aTr)

Uses of AnalyzedTokenReadings in org.languagetool.rules.fa

Methods in org.languagetool.rules.fa with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
boolean	PersianWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
protected boolean	PersianWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)

Uses of AnalyzedTokenReadings in org.languagetool.rules.fr

Methods in org.languagetool.rules.fr that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected List<AnalyzedTokenReadings>	FrenchPartialPosTagFilter.tag(String token)

Methods in org.languagetool.rules.fr with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	DMYDateCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	InterrogativeVerbFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PostponedAdjectiveConcordanceFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	SuggestionsFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	WordWithDeterminerFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
private AnalyzedToken	PostponedAdjectiveConcordanceFilter.getAnalyzedToken(AnalyzedTokenReadings aToken, Pattern pattern)
private AnalyzedToken	WordWithDeterminerFilter.getAnalyzedToken(AnalyzedTokenReadings aToken, Pattern pattern)
protected List<String>	FindSuggestionsFilter.getSpellingSuggestions(AnalyzedTokenReadings atr)
protected boolean	QuestionWhitespaceRule.isAllowedWhitespaceChar(AnalyzedTokenReadings[] tokens, int i)
protected boolean	QuestionWhitespaceStrictRule.isAllowedWhitespaceChar(AnalyzedTokenReadings[] tokens, int i)
protected boolean	FrenchRepeatedWordsRule.isException(AnalyzedTokenReadings[] tokens, int i, boolean sentStart, boolean isCapitalized, boolean isAllUppercase)
private boolean	PostponedAdjectiveConcordanceFilter.keepCounting(AnalyzedTokenReadings aTr)
private boolean	MorfologikFrenchSpellerRule.matchPostagRegexp(AnalyzedTokenReadings aToken, Pattern pattern)	Match POS tag with regular expression
private boolean	PostponedAdjectiveConcordanceFilter.matchPostagRegexp(AnalyzedTokenReadings aToken, Pattern pattern)	Match POS tag with regular expression
private void	PostponedAdjectiveConcordanceFilter.updateApparitions(AnalyzedTokenReadings aTr)
private int	PostponedAdjectiveConcordanceFilter.updateJValue(AnalyzedTokenReadings[] tokens, int i, int j, int level)

Uses of AnalyzedTokenReadings in org.languagetool.rules.ga

Methods in org.languagetool.rules.ga that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected List<AnalyzedTokenReadings>	IrishPartialPosTagFilter.tag(String token)
protected List<AnalyzedTokenReadings>	NoDisambiguationIrishPartialPosTagFilter.tag(String token)

Methods in org.languagetool.rules.ga with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private boolean	DhaNoBeirtRule.isNumber(AnalyzedTokenReadings tok)
private boolean	DhaNoBeirtRule.isPerson(AnalyzedTokenReadings tok)

Uses of AnalyzedTokenReadings in org.languagetool.rules.it

Methods in org.languagetool.rules.it with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
boolean	ItalianWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)

Uses of AnalyzedTokenReadings in org.languagetool.rules.km

Methods in org.languagetool.rules.km with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private boolean	KhmerWordRepeatRule.ignore(AnalyzedSentence sentence, AnalyzedTokenReadings[] tokensWithWhiteSpace, int position)

Uses of AnalyzedTokenReadings in org.languagetool.rules.nl

Methods in org.languagetool.rules.nl with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	CompoundFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
List<RuleMatch>	MorfologikDutchSpellerRule.getRuleMatches(String word, int startPos, AnalyzedSentence sentence, List<RuleMatch> ruleMatchesSoFar, int idx, AnalyzedTokenReadings[] tokens)

Uses of AnalyzedTokenReadings in org.languagetool.rules.patterns

Fields in org.languagetool.rules.patterns declared as AnalyzedTokenReadings

Modifier and Type	Field	Description
private AnalyzedTokenReadings	MatchState.formattedToken
private AnalyzedTokenReadings	MatchState.matchedToken
protected AnalyzedTokenReadings[]	AbstractPatternRulePerformer.unifiedTokens

Fields in org.languagetool.rules.patterns with type parameters of type AnalyzedTokenReadings

Modifier and Type	Field	Description
private final Map<PatternToken,List<AnalyzedTokenReadings>>	AbstractPatternRulePerformer.neutralReadings
private final List<AnalyzedTokenReadings>	Unifier.tokSequence

Methods in org.languagetool.rules.patterns that return AnalyzedTokenReadings

Modifier and Type	Method	Description
final AnalyzedTokenReadings	MatchState.filterReadings()
final AnalyzedTokenReadings[]	Unifier.getFinalUnified()	Used for getting a unified sequence in case when simple test method Unifier.isUnified(AnalyzedToken, Map, boolean)} was used.
final AnalyzedTokenReadings[]	Unifier.getUnifiedTokens()	Gets a full sequence of filtered tokens.

Methods in org.languagetool.rules.patterns with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	ApostropheTypeFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
abstract RuleMatch	RuleFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)	Returns the original rule match or a modified one, or null if the rule match is filtered out.
final void	Unifier.addNeutralElement(AnalyzedTokenReadings analyzedTokenReadings)	Used to add neutral elements (AnalyzedTokenReadings to the unified sequence.
PatternToken	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).
private String[]	PatternRuleMatcher.concatMatches(int start, int index, int tokenIndex, AnalyzedTokenReadings[] tokens, int nextTokenPos, List<Match> suggestionMatches)	Concatenates the matches, and takes care of phrases (including inflection using synthesis).
private RuleMatch	PatternRuleMatcher.createRuleMatch(int[] tokenPositions, AnalyzedTokenReadings[] tokens, int firstMatchToken, int lastMatchToken, int firstMarkerMatchToken, int lastMarkerMatchToken, AnalyzedSentence sentence)
MatchState	Match.createState(Synthesizer synthesizer, AnalyzedTokenReadings token)	Creates a state used for actually matching a token.
MatchState	Match.createState(Synthesizer synthesizer, AnalyzedTokenReadings[] tokens, int index, int next)	Creates a state used for actually matching a token.
private void	PatternToken.doCompile(AnalyzedTokenReadings token, Synthesizer synth)
protected void	AbstractPatternRulePerformer.doMatch(AnalyzedSentence sentence, AnalyzedTokenReadings[] tokens, AbstractPatternRulePerformer.MatchConsumer consumer)
private String	PatternRuleMatcher.formatMatches(AnalyzedTokenReadings[] tokenReadings, int[] positions, int firstMatchTok, String errorMsg, List<Match> suggestionMatches)	Replace back references generated with <match> and \\1 in message using Match class, and take care of skipping.
protected int	RuleFilter.getPosition(String fromStr, AnalyzedTokenReadings[] patternTokens, RuleMatch match)
Map<String,String>	RuleFilterEvaluator.getResolvedArguments(String filterArgs, AnalyzedTokenReadings[] patternTokens, int patternTokenPos, List<Integer> tokenPositions)	Resolves the backref arguments, e.g.
protected boolean	RuleFilter.isMatchAtSentenceStart(AnalyzedTokenReadings[] tokens, RuleMatch match)
boolean	PatternToken.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	PatternTokenMatcher.isMatchedByPreviousException(AnalyzedTokenReadings token)
boolean	RuleFilter.matches(Map<String,String> arguments, AnalyzedTokenReadings[] patternTokens, int firstMatchToken, List<Integer> tokenPositions)
private void	AbstractPatternRulePerformer.matchFrom(int startIndex, AnalyzedTokenReadings[] tokens, AbstractPatternRulePerformer.MatchConsumer consumer, int[] tokenPositions)
(package private) void	PatternTokenMatcher.prepareAndGroup(int firstMatchToken, AnalyzedTokenReadings[] tokens, Language language)
void	PatternTokenMatcher.resolveReference(int firstMatchToken, AnalyzedTokenReadings[] tokens, Language language)
RuleMatch	RuleFilterEvaluator.runFilter(String filterArgs, RuleMatch ruleMatch, AnalyzedTokenReadings[] patternTokens, int patternTokenPos, List<Integer> tokenPositions)
void	MatchState.setToken(AnalyzedTokenReadings token)
final void	MatchState.setToken(AnalyzedTokenReadings[] tokens, int index, int next)	Sets the token to be formatted etc.
private int	AbstractPatternRulePerformer.skipMaxTokens(AnalyzedTokenReadings[] tokens, PatternTokenMatcher elem, int firstMatchToken, int prevSkipNext, PatternTokenMatcher prevElement, int m, int remainingElems)
protected boolean	AbstractPatternRulePerformer.testAllReadings(AnalyzedTokenReadings[] tokens, PatternTokenMatcher matcher, PatternTokenMatcher prevElement, int tokenNo, int firstMatchToken, int prevSkipNext)
protected boolean	PatternRuleMatcher.testAllReadings(AnalyzedTokenReadings[] tokens, PatternTokenMatcher matcher, PatternTokenMatcher prevElement, int tokenNo, int firstMatchToken, int prevSkipNext)

Method parameters in org.languagetool.rules.patterns with type arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private void	Unifier.addTokenToSequence(List<AnalyzedTokenReadings> tokenSequence, AnalyzedToken token, int pos)

Uses of AnalyzedTokenReadings in org.languagetool.rules.pl

Methods in org.languagetool.rules.pl with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	DecadeSpellingFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
protected List<RuleMatch>	MorfologikPolishSpellerRule.getRuleMatches(String word, int startPos, AnalyzedSentence sentence, List<RuleMatch> ruleMatchesSoFar, int idx, AnalyzedTokenReadings[] tokens)

Uses of AnalyzedTokenReadings in org.languagetool.rules.pt

Fields in org.languagetool.rules.pt with type parameters of type AnalyzedTokenReadings

Modifier and Type	Field	Description
private static final Map<String,AnalyzedTokenReadings>	PortugueseAccentuationCheckRule.relevantWords
private static final Map<String,AnalyzedTokenReadings>	PortugueseAccentuationCheckRule.relevantWords2
private final Map<String,AnalyzedTokenReadings>	ConfusionCheckFilter.relevantWordsBR
private final Map<String,AnalyzedTokenReadings>	ConfusionCheckFilter.relevantWordsPT

Methods in org.languagetool.rules.pt that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
(package private) Map<String,AnalyzedTokenReadings>	ConfusionPairsDataLoader.loadWords(List<String> filepaths)
(package private) Map<String,AnalyzedTokenReadings>	PortugueseAccentuationDataLoader.loadWords(String path)
protected List<AnalyzedTokenReadings>	NoDisambiguationPortuguesePartialPosTagFilter.tag(String token)

Methods in org.languagetool.rules.pt with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	ConfusionCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PortugueseEnclisisFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	PortugueseProclisisFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	RegularIrregularParticipleFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	RomanNumeralFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	YMDDateCheckFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
RuleMatch	YMDNewYearDateFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
private List<String>	PortugueseEnclisisFilter.getPronounTags(AnalyzedTokenReadings pronounReadings, String verbText, boolean convertToAccusative)
List<RuleMatch>	MorfologikPortugueseSpellerRule.getRuleMatches(String word, int startPos, AnalyzedSentence sentence, List<RuleMatch> ruleMatchesSoFar, int idx, AnalyzedTokenReadings[] tokens)
private ArrayList<String>	PortugueseEnclisisFilter.getVerbForms(AnalyzedTokenReadings verbStemTokenReadings, List<String> pronounTags)
boolean	PortugueseWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
protected boolean	PortugueseWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)
boolean	PortugueseFillerWordsRule.isException(AnalyzedTokenReadings[] tokens, int num)
private boolean	PortugueseWordRepeatRule.isGenus(AnalyzedTokenReadings token)
private boolean	PortugueseWordRepeatRule.isHyphenated(AnalyzedTokenReadings[] tokens, int position)
private boolean	PortugueseWordRepeatRule.isPronoun(AnalyzedTokenReadings token)
private boolean	PortugueseWordRepeatRule.isReduplicatedAdverb(AnalyzedTokenReadings token)
private boolean	PortugueseWordRepeatRule.isSpecies(AnalyzedTokenReadings token)
protected boolean	BrazilianPortugueseReplaceRule.isTokenException(AnalyzedTokenReadings atr)
protected boolean	PortugalPortugueseReplaceRule.isTokenException(AnalyzedTokenReadings atr)
protected boolean	PortugueseBarbarismsRule.isTokenException(AnalyzedTokenReadings atr)
private boolean	PortugueseAccentuationCheckRule.matchPostagRegexp(AnalyzedTokenReadings aToken, Pattern pattern)	Match POS tag with regular expression

Uses of AnalyzedTokenReadings in org.languagetool.rules.ro

Methods in org.languagetool.rules.ro with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected boolean	RomanianWordRepeatBeginningRule.isAdverb(AnalyzedTokenReadings token)

Uses of AnalyzedTokenReadings in org.languagetool.rules.ru

Methods in org.languagetool.rules.ru that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected List<AnalyzedTokenReadings>	NoDisambiguationRussianPartialPosTagFilter.tag(String token)
protected List<AnalyzedTokenReadings>	RussianPartialPosTagFilter.tag(String token)

Methods in org.languagetool.rules.ru with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	INNNumberFilter.acceptRuleMatch(RuleMatch match, Map<String,String> args, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)
private void	RussianVerbConjugationRule.addRuleMatch(List<RuleMatch> ruleMatches, AnalyzedTokenReadings currentReading, AnalyzedTokenReadings nextReading, AnalyzedSentence sentence)
boolean	RussianSimpleWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
protected boolean	MorfologikRussianSpellerRule.ignoreToken(AnalyzedTokenReadings[] tokens, int idx)
protected boolean	MorfologikRussianYOSpellerRule.ignoreToken(AnalyzedTokenReadings[] tokens, int idx)
boolean	RussianFillerWordsRule.isException(AnalyzedTokenReadings[] tokens, int num)

Uses of AnalyzedTokenReadings in org.languagetool.rules.spelling

Methods in org.languagetool.rules.spelling with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected boolean	SpellingCheckRule.ignoreToken(AnalyzedTokenReadings[] tokens, int idx)	Returns true iff the token at the given position should be ignored by the spell checker.

Uses of AnalyzedTokenReadings in org.languagetool.rules.spelling.morfologik

Methods in org.languagetool.rules.spelling.morfologik with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private boolean	MorfologikSpellerRule.canBeIgnored(AnalyzedTokenReadings[] tokens, int idx, AnalyzedTokenReadings token)
protected List<RuleMatch>	MorfologikSpellerRule.getRuleMatches(String word, int startPos, AnalyzedSentence sentence, List<RuleMatch> ruleMatchesSoFar, int idx, AnalyzedTokenReadings[] tokens)

Uses of AnalyzedTokenReadings in org.languagetool.rules.spelling.multitoken

Methods in org.languagetool.rules.spelling.multitoken with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
RuleMatch	MultitokenSpellerFilter.acceptRuleMatch(RuleMatch match, Map<String,String> arguments, int patternTokenPos, AnalyzedTokenReadings[] patternTokens, List<Integer> tokenPositions)

Uses of AnalyzedTokenReadings in org.languagetool.rules.uk

Fields in org.languagetool.rules.uk declared as AnalyzedTokenReadings

Modifier and Type	Field	Description
(package private) AnalyzedTokenReadings	TokenAgreementAdjNounRule.State.adjAnalyzedTokenReadings
(package private) AnalyzedTokenReadings	TokenAgreementNounVerbRule.State.nounAnalyzedTokenReadings
(package private) AnalyzedTokenReadings	TokenAgreementNumrNounRule.State.numrAnalyzedTokenReadings
(package private) AnalyzedTokenReadings	TokenAgreementPrepNounRule.State.prepTokenReadings
(package private) final AnalyzedTokenReadings[]	SearchHelper.Context.tokens
(package private) AnalyzedTokenReadings	TokenAgreementVerbNounRule.State.verbAnalyzedTokenReadings

Methods in org.languagetool.rules.uk with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private static boolean	TokenAgreementVerbNounExceptionHelper.agrees(AnalyzedTokenReadings verbTokenReadings, List<VerbInflectionHelper.Inflection> nounAdjNazInflections, List<AnalyzedToken> nounAdjIndirTokenReadings)
private boolean	SearchHelper.Match.canSkip(AnalyzedTokenReadings currentToken, SearchHelper.Context context)
private static boolean	TokenAgreementAdjNounExceptionHelper.checkTextInSent(AnalyzedTokenReadings[] tokens, int pos, String text)
private RuleMatch	HiddenCharacterRule.createRuleMatch(AnalyzedTokenReadings readings, AnalyzedSentence sentence)
private RuleMatch	MixedAlphabetsRule.createRuleMatch(AnalyzedTokenReadings readings, List<String> replacements, String msg, AnalyzedSentence sentence)
private RuleMatch	SimpleReplaceRenamedRule.createRuleMatch(AnalyzedTokenReadings readings, List<String> replacements, String msg, String info, AnalyzedSentence sentence)
private RuleMatch	TokenAgreementPrepNounRule.createRuleMatch(TokenAgreementPrepNounRule.State state, AnalyzedSentence sentence, AnalyzedTokenReadings[] tokens, int i)
private RuleMatch	TypographyRule.createRuleMatch(AnalyzedTokenReadings readings, List<String> replacements, String msg, AnalyzedSentence sentence)
private static int	TokenAgreementPrepNounRule.findInsertEnd(AnalyzedTokenReadings prepTokenReadings, AnalyzedTokenReadings[] tokens, int i, boolean lookForPart)
protected List<RuleMatch>	SimpleReplaceRule.findMatches(AnalyzedTokenReadings tokenReadings, AnalyzedSentence sentence)
private static boolean	TokenAgreementAdjNounExceptionHelper.forwardConjFind(AnalyzedTokenReadings[] tokens, int pos, int depth)
(package private) static int	LemmaHelper.forwardLemmaSearchIdx(AnalyzedTokenReadings[] tokens, int pos, int depth, Pattern lemma, Pattern postag)
(package private) static boolean	LemmaHelper.forwardPosTagSearch(AnalyzedTokenReadings[] tokens, int pos, String posTag, int maxSkip)
static Set<String>	CaseGovernmentHelper.getCaseGovernments(AnalyzedTokenReadings analyzedTokenReadings, String startPosTag)
static Set<String>	CaseGovernmentHelper.getCaseGovernments(AnalyzedTokenReadings analyzedTokenReadings, Pattern posTag)
private static ArrayList<String>	CaseGovernmentHelper.getCustomGovs(AnalyzedTokenReadings analyzedTokenReadings)
static RuleException	TokenAgreementPrepNounExceptionHelper.getExceptionInfl(AnalyzedTokenReadings[] tokens, int i, TokenAgreementPrepNounRule.State state)
static RuleException	TokenAgreementPrepNounExceptionHelper.getExceptionNonInfl(AnalyzedTokenReadings[] tokens, int i, TokenAgreementPrepNounRule.State state)
static RuleException	TokenAgreementPrepNounExceptionHelper.getExceptionStrong(AnalyzedTokenReadings[] tokens, int i, AnalyzedTokenReadings prepTokenReadings)
private static AnalyzedToken	TokenAgreementPrepNounRule.getMultiwordToken(AnalyzedTokenReadings analyzedTokenReadings)
private String	MissingHyphenRule.getPrefixExtraTag(AnalyzedTokenReadings tokenReadings, boolean isCapitalized)
protected List<RuleMatch>	MorfologikUkrainianSpellerRule.getRuleMatches(String word, int startPos, AnalyzedSentence sentence, List<RuleMatch> ruleMatchesSoFar, int idx, AnalyzedTokenReadings[] tokens)
private List<String>	TokenAgreementVerbNounRule.getSuggestions(Set<String> cases, AnalyzedTokenReadings tokenReadings)
private TokenAgreementVerbNounRule.State	TokenAgreementVerbNounRule.getVerbState(AnalyzedTokenReadings[] tokens, int i)
static boolean	CaseGovernmentHelper.hasCaseGovernment(AnalyzedTokenReadings analyzedTokenReadings, String rvCase)
static boolean	CaseGovernmentHelper.hasCaseGovernment(AnalyzedTokenReadings analyzedTokenReadings, Pattern startPosTag, String rvCase)
private static boolean	MorfologikUkrainianSpellerRule.hasGoodTag(AnalyzedTokenReadings tokens)
static boolean	LemmaHelper.hasLemma(AnalyzedTokenReadings analyzedTokenReadings, String lemma)
static boolean	LemmaHelper.hasLemma(AnalyzedTokenReadings analyzedTokenReadings, Collection<String> lemmas)
static boolean	LemmaHelper.hasLemma(AnalyzedTokenReadings analyzedTokenReadings, Collection<String> lemmas, Pattern posRegex)
static boolean	LemmaHelper.hasLemma(AnalyzedTokenReadings analyzedTokenReadings, List<String> lemmas, String partPos)
static boolean	LemmaHelper.hasLemma(AnalyzedTokenReadings analyzedTokenReadings, Pattern pattern)
static boolean	LemmaHelper.hasLemma(AnalyzedTokenReadings analyzedTokenReadings, Pattern pattern, Pattern posTagRegex)
static boolean	LemmaHelper.hasLemmaBase(AnalyzedTokenReadings analyzedTokenReadings, Collection<String> lemmas, Pattern posRegex)
(package private) static boolean	TokenAgreementPrepNounRule.hasVidmPosTag(Collection<String> posTagsToFind, AnalyzedTokenReadings tokenReadings)
boolean	UkrainianWordRepeatRule.ignore(AnalyzedTokenReadings[] tokens, int position)
private boolean	SearchHelper.Match.ignoreInserts(AnalyzedTokenReadings[] tokens, int pos, int dir)
protected boolean	MorfologikUkrainianSpellerRule.ignoreToken(AnalyzedTokenReadings[] tokens, int idx)
static boolean	LemmaHelper.isDash(AnalyzedTokenReadings analyzedTokenReadings)
static boolean	TokenAgreementAdjNounExceptionHelper.isException(AnalyzedTokenReadings[] tokens, int adjPos, int nounPos, List<InflectionHelper.Inflection> masterInflections, List<InflectionHelper.Inflection> slaveInflections, List<AnalyzedToken> adjTokenReadings, List<AnalyzedToken> slaveTokenReadings)
static boolean	TokenAgreementNounVerbExceptionHelper.isException(AnalyzedTokenReadings[] tokens, int nounPos, int verbPos, List<VerbInflectionHelper.Inflection> nounInflections, List<VerbInflectionHelper.Inflection> verbInflections, List<AnalyzedToken> nounTokenReadings, List<AnalyzedToken> verbTokenReadings)
static boolean	TokenAgreementNumrNounExceptionHelper.isException(AnalyzedTokenReadings[] tokens, TokenAgreementNumrNounRule.State state, List<InflectionHelper.Inflection> numrInflections, List<InflectionHelper.Inflection> slaveInflections, List<AnalyzedToken> slaveTokenReadings)
static boolean	TokenAgreementVerbNounExceptionHelper.isException(AnalyzedTokenReadings[] tokens, TokenAgreementVerbNounRule.State state, List<VerbInflectionHelper.Inflection> verbInflections, List<VerbInflectionHelper.Inflection> nounAdjInflections, List<AnalyzedToken> verbTokenReadings, List<AnalyzedToken> nounTokenReadings)
protected boolean	UkrainianCommaWhitespaceRule.isException(AnalyzedTokenReadings[] tokens, int tokenIdx)
protected boolean	UkrainianUppercaseSentenceStartRule.isException(AnalyzedTokenReadings[] tokens, int tokenIdx)
(package private) static int	TokenAgreementVerbNounExceptionHelper.isExceptionHardAdjNoun(AnalyzedTokenReadings[] tokens, int i, TokenAgreementVerbNounRule.State state)
(package private) static int	TokenAgreementVerbNounExceptionHelper.isExceptionSkip(AnalyzedTokenReadings[] tokens, int i)
(package private) static RuleException	TokenAgreementVerbNounExceptionHelper.isExceptionVerb(AnalyzedTokenReadings[] tokens, int i, TokenAgreementVerbNounRule.State state)
static boolean	LemmaHelper.isInitial(AnalyzedTokenReadings analyzedTokenReadings)
private boolean	UkrainianWordRepeatRule.isInitial(AnalyzedToken analyzedToken, AnalyzedTokenReadings[] tokens, int position)
private boolean	TokenAgreementPrepNounRule.isLikelyApproxWithZi(AnalyzedTokenReadings[] tokens, int i, TokenAgreementPrepNounRule.State state)
(package private) static boolean	TokenAgreementNounVerbExceptionHelper.isNonPluralA(AnalyzedTokenReadings[] tokens, int pos)
private static boolean	TypographyRule.isNumber(AnalyzedTokenReadings analyzedTokenReadings)
private boolean	TokenAgreementNumrNounRule.isNynCase(AnalyzedTokenReadings[] tokens, int i)
(package private) static boolean	LemmaHelper.isPossiblyProperNoun(AnalyzedTokenReadings analyzedTokenReadings)
protected boolean	SimpleReplaceRule.isTagged(AnalyzedTokenReadings tokenReadings)
protected boolean	SimpleReplaceSoftRule.isTokenException(AnalyzedTokenReadings atr)
private boolean	MixedAlphabetsRule.likelyBadLatinI(AnalyzedTokenReadings[] tokens, int i)
int	SearchHelper.Match.mAfter(AnalyzedTokenReadings[] tokens, int pos)
boolean	SearchHelper.Condition.matches(AnalyzedTokenReadings analyzedTokenReadings, SearchHelper.Context context)
int	SearchHelper.Match.mBefore(AnalyzedTokenReadings[] tokens, int pos)
int	SearchHelper.Match.mNow(AnalyzedTokenReadings[] tokens, int pos)
private static boolean	TokenAgreementAdjNounExceptionHelper.reverseConjAdvFind(AnalyzedTokenReadings[] tokens, int pos, int depth)
private static boolean	TokenAgreementAdjNounExceptionHelper.reverseConjFind(AnalyzedTokenReadings[] tokens, int pos, int depth)
private static boolean	TokenAgreementAdjNounExceptionHelper.reverseConjFind2(AnalyzedTokenReadings[] tokens, int pos, int depth)
(package private) static boolean	LemmaHelper.reverseSearch(AnalyzedTokenReadings[] tokens, int pos, int depth, Pattern lemma, Pattern postag)
(package private) static int	LemmaHelper.reverseSearchIdx(AnalyzedTokenReadings[] tokens, int pos, int depth, Pattern lemma, Pattern postag)
(package private) static boolean	LemmaHelper.revSearch(AnalyzedTokenReadings[] tokens, int startPos, Pattern lemma, String postagRegex)
(package private) static int	LemmaHelper.revSearchIdx(AnalyzedTokenReadings[] tokens, int startPos, Pattern lemma, String postagRegex)
private String	TypographyRule.shortDashToken(AnalyzedTokenReadings tokenReadings)
(package private) static int	LemmaHelper.tokenSearch(AnalyzedTokenReadings[] tokens, int pos, String posTag, Pattern token, Pattern posTagsToIgnore, LemmaHelper.Dir dir)
(package private) static int	LemmaHelper.tokenSearch(AnalyzedTokenReadings[] tokens, int pos, Pattern posTag, Pattern token, Pattern posTagsToIgnore, LemmaHelper.Dir dir)

Constructors in org.languagetool.rules.uk with parameters of type AnalyzedTokenReadings

Modifier	Constructor	Description
	Context(AnalyzedTokenReadings[] tokens, int pos)

Uses of AnalyzedTokenReadings in org.languagetool.server

Methods in org.languagetool.server with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
protected List<String>	RemoteSynthesizer.synthesize(String languageCode, AnalyzedTokenReadings atrs, boolean postagRegexp, String postagSelect, String postagReplace, String lemmaReplace)

Uses of AnalyzedTokenReadings in org.languagetool.tagging

Methods in org.languagetool.tagging that return AnalyzedTokenReadings

Modifier and Type	Method	Description
final AnalyzedTokenReadings	BaseTagger.createNullToken(String token, int startPos)
AnalyzedTokenReadings	Tagger.createNullToken(String token, int startPos)	Create the AnalyzedToken used for whitespace and other non-words.

Methods in org.languagetool.tagging that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	BaseTagger.tag(List<String> sentenceTokens)
List<AnalyzedTokenReadings>	Tagger.tag(List<String> sentenceTokens)	Returns a list of AnalyzedTokens that assigns each term in the sentence some kind of part-of-speech information (not necessarily just one tag).

Uses of AnalyzedTokenReadings in org.languagetool.tagging.ar

Methods in org.languagetool.tagging.ar that return AnalyzedTokenReadings

Modifier and Type	Method	Description
AnalyzedTokenReadings	ArabicTagger.tag(String word)

Methods in org.languagetool.tagging.ar that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	ArabicTagger.tag(List<String> sentenceTokens)

Methods in org.languagetool.tagging.ar with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<String>	ArabicTagger.getLemmas(AnalyzedTokenReadings patternTokens, String type)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.br

Methods in org.languagetool.tagging.br that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	BretonTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.ca

Methods in org.languagetool.tagging.ca that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	CatalanTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.de

Methods in org.languagetool.tagging.de that return AnalyzedTokenReadings

Modifier and Type	Method	Description
AnalyzedTokenReadings	GermanTagger.lookup(String word)	Return only the first reading of the given word or null.

Methods in org.languagetool.tagging.de that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	GermanTagger.tag(List<String> sentenceTokens)
List<AnalyzedTokenReadings>	GermanTagger.tag(List<String> sentenceTokens, boolean ignoreCase)
List<AnalyzedTokenReadings>	SwissGermanTagger.tag(List<String> sentenceTokens, boolean ignoreCase)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.disambiguation

Methods in org.languagetool.tagging.disambiguation that return AnalyzedTokenReadings

Modifier and Type	Method	Description
private AnalyzedTokenReadings	MultiWordChunker.prepareNewReading(AnalyzedToken at, String token, AnalyzedTokenReadings atrs, boolean isLast)
protected AnalyzedTokenReadings	MultiWordChunker2.prepareNewReading(String tokens, String tok, AnalyzedTokenReadings token, String tag)
private AnalyzedTokenReadings[]	MultiWordChunker.removePreviousTags(AnalyzedTokenReadings[] aTokens)
private AnalyzedTokenReadings	MultiWordChunker.setAndAnnotate(AnalyzedTokenReadings oldReading, AnalyzedToken newReading)
private AnalyzedTokenReadings	MultiWordChunker2.setAndAnnotate(AnalyzedTokenReadings oldReading, AnalyzedToken newReading)

Methods in org.languagetool.tagging.disambiguation with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private MultiWordChunker2.MultiWordEntry	MultiWordChunker2.findMultiwordEntry(AnalyzedTokenReadings[] inputTokens, int startingPosition, List<MultiWordChunker2.MultiWordEntry> multiwordItems)
private AnalyzedToken	MultiWordChunker.getMultiWordAnalyzedToken(AnalyzedTokenReadings[] aTokens, Integer i)
private boolean	MultiWordChunker2.isMatching(AnalyzedTokenReadings[] inputTokens, int startingPosition, MultiWordChunker2.MultiWordEntry multiWordEntry)
protected boolean	MultiWordChunker2.matches(String matchText, AnalyzedTokenReadings inputTokens)
private AnalyzedTokenReadings	MultiWordChunker.prepareNewReading(AnalyzedToken at, String token, AnalyzedTokenReadings atrs, boolean isLast)
protected AnalyzedTokenReadings	MultiWordChunker2.prepareNewReading(String tokens, String tok, AnalyzedTokenReadings token, String tag)
private AnalyzedTokenReadings[]	MultiWordChunker.removePreviousTags(AnalyzedTokenReadings[] aTokens)
private AnalyzedTokenReadings	MultiWordChunker.setAndAnnotate(AnalyzedTokenReadings oldReading, AnalyzedToken newReading)
private AnalyzedTokenReadings	MultiWordChunker2.setAndAnnotate(AnalyzedTokenReadings oldReading, AnalyzedToken newReading)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.disambiguation.rules

Methods in org.languagetool.tagging.disambiguation.rules that return AnalyzedTokenReadings

Modifier and Type	Method	Description
private AnalyzedTokenReadings[]	DisambiguationPatternRuleReplacer.executeAction(AnalyzedSentence sentence, AnalyzedTokenReadings[] whiteTokens, AnalyzedTokenReadings[] unifiedTokens, int firstMatchToken, int lastMatchToken, int matchingTokens, int[] tokenPositions)

Methods in org.languagetool.tagging.disambiguation.rules with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private AnalyzedTokenReadings[]	DisambiguationPatternRuleReplacer.executeAction(AnalyzedSentence sentence, AnalyzedTokenReadings[] whiteTokens, AnalyzedTokenReadings[] unifiedTokens, int firstMatchToken, int lastMatchToken, int matchingTokens, int[] tokenPositions)
private boolean	DisambiguationPatternRuleReplacer.keepDespiteFilter(AnalyzedTokenReadings[] tokens, int[] tokenPositions, int firstMatchToken, int lastMatchToken)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.disambiguation.uk

Methods in org.languagetool.tagging.disambiguation.uk that return AnalyzedTokenReadings

Modifier and Type	Method	Description
private static AnalyzedTokenReadings	UkrainianHybridDisambiguator.getInitialReadings(AnalyzedTokenReadings initialsReadings, AnalyzedTokenReadings lnameTokens, String initialType)

Methods in org.languagetool.tagging.disambiguation.uk with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
private static void	UkrainianHybridDisambiguator.checkForInitialRetag(AnalyzedTokenReadings lastName, List<Integer> initialsIdxs, AnalyzedTokenReadings[] tokens)
private static AnalyzedTokenReadings	UkrainianHybridDisambiguator.getInitialReadings(AnalyzedTokenReadings initialsReadings, AnalyzedTokenReadings lnameTokens, String initialType)
private static boolean	UkrainianHybridDisambiguator.isInitial(AnalyzedTokenReadings[] tokens, int pos)
private boolean	UkrainianHybridDisambiguator.likelyVklyContext(AnalyzedTokenReadings[] tokens, int i)
protected boolean	UkrainianMultiwordChunker.matches(String matchText, AnalyzedTokenReadings inputTokens)
private static void	UkrainianHybridDisambiguator.removeTokensWithout(AnalyzedTokenReadings readings, Pattern pattern)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.en

Methods in org.languagetool.tagging.en that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	EnglishTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.eo

Methods in org.languagetool.tagging.eo that return AnalyzedTokenReadings

Modifier and Type	Method	Description
AnalyzedTokenReadings	EsperantoTagger.createNullToken(String token, int startPos)

Methods in org.languagetool.tagging.eo that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	EsperantoTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.es

Methods in org.languagetool.tagging.es that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	SpanishTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.fr

Methods in org.languagetool.tagging.fr that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	FrenchTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.ga

Methods in org.languagetool.tagging.ga that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
final List<AnalyzedTokenReadings>	IrishTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.gl

Methods in org.languagetool.tagging.gl that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	GalicianTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.ja

Methods in org.languagetool.tagging.ja that return AnalyzedTokenReadings

Modifier and Type	Method	Description
final AnalyzedTokenReadings	JapaneseTagger.createNullToken(String token, int startPos)

Methods in org.languagetool.tagging.ja that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	JapaneseTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.nl

Methods in org.languagetool.tagging.nl that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	DutchTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.pl

Methods in org.languagetool.tagging.pl that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
final List<AnalyzedTokenReadings>	PolishTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.pt

Methods in org.languagetool.tagging.pt that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	PortugueseTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.ru

Methods in org.languagetool.tagging.ru that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	RussianTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.uk

Methods in org.languagetool.tagging.uk with parameters of type AnalyzedTokenReadings

Modifier and Type	Method	Description
static List<AnalyzedToken>	PosTagHelper.filter(AnalyzedTokenReadings tokens, Pattern postag, Pattern token)
static String	PosTagHelper.getGenders(AnalyzedTokenReadings tokenReadings, String posTagRegex)
static String	PosTagHelper.getGenders(AnalyzedTokenReadings tokenReadings, Pattern posTagRegex)
static boolean	PosTagHelper.hasMaleUA(AnalyzedTokenReadings tokenReadings)
static boolean	PosTagHelper.hasPosTag(AnalyzedTokenReadings analyzedTokenReadings, String posTagRegex)
static boolean	PosTagHelper.hasPosTag(AnalyzedTokenReadings analyzedTokenReadings, Pattern posTagRegex)
static boolean	PosTagHelper.hasPosTagAndToken(AnalyzedTokenReadings tokens, Pattern postag, Pattern token)
static boolean	PosTagHelper.hasPosTagPart(AnalyzedTokenReadings analyzedTokenReadings, String posTagPart)
static boolean	PosTagHelper.hasPosTagPartAll(AnalyzedTokenReadings analyzedTokenReadings, String posTagPart)
static boolean	PosTagHelper.hasPosTagStart(AnalyzedTokenReadings analyzedTokenReadings, String posTagPart)
static boolean	PosTagHelper.isUnknownWord(AnalyzedTokenReadings analyzedTokenReadings)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.xx

Methods in org.languagetool.tagging.xx that return AnalyzedTokenReadings

Modifier and Type	Method	Description
AnalyzedTokenReadings	DemoTagger.createNullToken(String token, int startPos)

Methods in org.languagetool.tagging.xx that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	DemoTagger.tag(List<String> sentenceTokens)

Uses of AnalyzedTokenReadings in org.languagetool.tagging.zh

Methods in org.languagetool.tagging.zh that return AnalyzedTokenReadings

Modifier and Type	Method	Description
final AnalyzedTokenReadings	ChineseTagger.createNullToken(String token, int startPos)

Methods in org.languagetool.tagging.zh that return types with arguments of type AnalyzedTokenReadings

Modifier and Type	Method	Description
List<AnalyzedTokenReadings>	ChineseTagger.tag(List<String> sentenceTokens)