# All Classes and Interfaces

Class
Description
AbstractBottomUpParser
Abstract class which contains code to tag and chunk parses for bottom up parsing and leaves implementation of advancing parses and completing parses to extend class.
AbstractContextGenerator
Abstract class containing many of the methods used to generate contexts for parsing.
AbstractEventStream<T>
A base `ObjectStream` implementation for events.
AbstractParserEventStream
Abstract class extended by parser event streams which perform tagging and chunking.
AccentFoldCharSequenceNormalizer
A `CharSequenceNormalizer` that folds diacritics for matching, the multilingual-safe counterpart to a Latin-only ASCII folding filter.
AdditionalContextFeatureGenerator
The `AdditionalContextFeatureGenerator` generates the context from the passed in additional context.
AggregateCharSequenceNormalizer
A `CharSequenceNormalizer` implementation that aggregates the functionality of other normalizers.
AggregatedFeatureGenerator
The `AggregatedFeatureGenerator` aggregates a set of `feature generators` and calls them to generate the features.
AggregatedFeatureGeneratorFactory
A `GeneratorFactory` that produces `AggregatedFeatureGenerator` instances when `AggregatedFeatureGeneratorFactory.create()` is called.
Among
Internal class used by Snowball stemmers
AncoraSpanishHeadRules
Class for storing the Ancora Spanish head rules associated with parsing.
AncoraSpanishHeadRules.HeadRulesSerializer
arabicStemmer
This class implements the stemming algorithm defined by a snowball script.
AttachContextGenerator
Generates predictive contexts for deciding how constituents should be attached.
Attributes
The `Attributes` class stores name value pairs.
BagOfWordsFeatureGenerator
Generates a feature for each word in a document.
BaseModel
This is a common base model which can be used by the components' specific model classes.
BaseToolFactory
Base class for all tool `factories`.
BigramNameFeatureGenerator
Adds bigram features based on tokens and token classes.
BigramNameFeatureGeneratorFactory
A `GeneratorFactory` that produces `BigramNameFeatureGenerator` instances when `BigramNameFeatureGeneratorFactory.create()` is called.
BilouCodec
The default `SequenceCodec` implementation according to the `BILOU` scheme.
BilouNameFinderSequenceValidator
A `SequenceValidator` implementation for the `BilouCodec`.
BioCodec
The default `SequenceCodec` implementation according to the `BIO` scheme: B: 'beginning' of a NE I: 'inside', the word is inside a NE O: 'outside', the word is a regular word outside a NE See also the paper by Roth D. and Ratinov L.: Design Challenges and Misconceptions in Named Entity Recognition.
BPEModel
The `BPEModel` stores learned BPE merge operations and can be serialized and deserialized for reuse.
BPETokenizer
A `Tokenizer` implementation that performs subword tokenization using Byte Pair Encoding (BPE).
BPETokenizer.SymbolPair
Represents a pair of adjacent symbols in BPE.
BPETokenizerFactory
A `BaseToolFactory` for BPE tokenization that manages the BPE merge rules artifact and its serialization within a `BPEModel`.
BPETokenizerTrainer
Learns BPE merge operations from a training corpus and produces a `BPEModel`.
BrownBigramFeatureGenerator
Generates Brown cluster features for token bigrams.
BrownCluster
Class to load a Brown cluster document in the format: `word\tword_class\tprob`.
BrownCluster.BrownClusterSerializer
BrownClusterBigramFeatureGeneratorFactory
A `GeneratorFactory` that produces `BrownBigramFeatureGenerator` instances when `BrownClusterBigramFeatureGeneratorFactory.create()` is called.
BrownClusterTokenClassFeatureGeneratorFactory
A `GeneratorFactory` that produces `BrownTokenClassFeatureGenerator` instances when `BrownClusterTokenClassFeatureGeneratorFactory.create()` is called.
BrownClusterTokenFeatureGeneratorFactory
A `GeneratorFactory` that produces `BrownTokenFeatureGenerator` instances when `BrownClusterTokenFeatureGeneratorFactory.create()` is called.
BrownTokenClasses
Obtain the paths listed in the pathLengths array from the Brown class.
BrownTokenClassFeatureGenerator
Generates `BrownCluster` features for current token and token class.
BrownTokenFeatureGenerator
Generates `BrownCluster` features for current token.
BuildContextGenerator
Generates predictive contexts for deciding how constituents should be combined.
BuildContextGenerator
Creates the features or contexts for the building phase of parsing.
BulletCharSequenceNormalizer
A `CharSequenceNormalizer` that replaces unambiguous list-bullet characters with a space, so a bullet acts as a token separator rather than sticking to the following word.
ByteArraySerializer
An `ArtifactSerializer` implementation for binary data, kept in `byte[]`.
CachedFeatureGenerator
Caches features of the aggregated `generators`.
CachedFeatureGeneratorFactory
A `GeneratorFactory` that produces `CachedFeatureGenerator` instances when `CachedFeatureGeneratorFactory.create()` is called.
CachingStemmer
A `Stemmer` that memoizes word-to-stem mappings in a bounded per-thread LRU cache.
CaseFoldCharSequenceNormalizer
A `CharSequenceNormalizer` that lower cases text for case-insensitive matching.
catalanStemmer
This class implements the stemming algorithm defined by a snowball script.
CharacterNgramFeatureGenerator
The `CharacterNgramFeatureGenerator` uses character ngrams to generate features about each token.
CharacterNgramFeatureGeneratorFactory
A `GeneratorFactory` that produces `CharacterNgramFeatureGenerator` instances when `CharacterNgramFeatureGeneratorFactory.create()` is called.
CheckContextGenerator
Generates predictive context for deciding when a constituent is complete.
CheckContextGenerator
Generates predictive context for deciding when a constituent is complete.
CHMStringDeduplicator
A `StringInterner` implementation by Aleksey Shipilëv with relaxed canonical requirements.
CHMStringInterner
A `StringInterner` implementation based on `ConcurrentHashMap` by Aleksey Shipilëv.
ChunkContextGenerator
Creates predictive context for the pre-chunking phases of parsing.
ChunkerCrossValidator
Cross validator for `Chunker`.
ChunkerEvaluator
The `ChunkerEvaluator` measures the performance of the given `Chunker` with the provided reference `samples`.
ChunkerEventStream
Class for creating an event stream out of data files for training a `Chunker`.
ChunkerFactory
ChunkerME
The class represents a maximum-entropy-based `Chunker`.
ChunkerModel
The `ChunkerModel` is the model used by a learnable `Chunker`.
ChunkerModelSerializer
An `ArtifactSerializer` implementation for `models`.
ChunkSampleSequenceStream
A `SequenceStream` implementation encapsulating `samples`.
ChunkSampleStream
Parses the conll 2000 shared task shallow parser training data.
ChunkSampleStream
CollectionObjectStream<E>
An `ObjectStream` implementation that works on a `Collection` of `CollectionObjectStream` as source for elements.
ConfigurablePOSContextGenerator
A configurable `context generator` for a `POSTagger`.
Confusables
Computes the Unicode confusable skeleton of text, following the skeleton algorithm defined in UTS #39 (Unicode Security Mechanisms).
ConfusableSkeletonCharSequenceNormalizer
A `CharSequenceNormalizer` that reduces text to its Unicode confusable skeleton (UTS #39).
Cons
Holds feature information about a specific `Parse` node.
CrossValidationPartitioner<E>
Provides access to training and test partitions for n-fold cross validation.
CrossValidationPartitioner.TrainingSampleStream<E>
The `CrossValidationPartitioner.TrainingSampleStream` which iterates over all training elements.
danishStemmer
This class implements the stemming algorithm defined by a snowball script.
DashCharSequenceNormalizer
A `CharSequenceNormalizer` that maps every Unicode dash to an ASCII hyphen-minus (`U+002D`), reusing the cursor based `CharClass.dashes()` engine.
DefaultChunkerContextGenerator
Features based on chunking model described in Fei Sha and Fernando Pereira.
DefaultChunkerSequenceValidator
The default chunker `SequenceValidator` implementation.
DefaultEndOfSentenceScanner
Default implementation of the `EndOfSentenceScanner`.
DefaultLanguageDetectorContextGenerator
A context generator for `language detector`.
DefaultLemmatizerContextGenerator
Simple feature generator for learning statistical lemmatizers.
DefaultLemmatizerSequenceValidator
The default lemmatizer `SequenceValidator` implementation.
DefaultNameContextGenerator
A `NameContextGenerator` implementation for determining contextual features for a `tag-chunk` style named-entity recognizer.
DefaultPOSContextGenerator
A default `context generator` for a `POSTagger`.
DefaultPOSSequenceValidator
The default POS tagger `SequenceValidator` implementation.
DefaultSDContextGenerator
Generate event contexts for maxent decisions for sentence detection.
DefaultTokenContextGenerator
A default `TokenContextGenerator` which produces events for maxent decisions for tokenization.
DefinitionFeatureGeneratorFactory
A `GeneratorFactory` that produces `OutcomePriorFeatureGenerator` instances when `DefinitionFeatureGeneratorFactory.create()` is called.
DetokenizationDictionary
DetokenizationDictionary.Operation
Dictionary
An iterable and serializable dictionary implementation.
DictionaryDetokenizer
A rule based detokenizer.
DictionaryEntryPersistor
A persistor used by for reading and writing `dictionaries` of all kinds.
DictionaryFeatureGenerator
The `DictionaryFeatureGenerator` uses a `DictionaryNameFinder` to generate features for detected names based on the `InSpanGenerator`.
DictionaryFeatureGeneratorFactory
A `GeneratorFactory` that produces `DictionaryFeatureGenerator` instances when `DictionaryFeatureGeneratorFactory.create()` is called.
DictionaryLemmatizer
A `Lemmatizer` implementation that works by simple dictionary lookup into a `Map` built from a file containing, for each line:
DictionaryNameFinder
This is a `Dictionary` based `name finder`.
DictionarySerializer
An `ArtifactSerializer` implementation for `dictionaries`.
DictionaryStopwordFilter
An immutable, thread-safe `StopwordFilter` backed by an OpenNLP `Dictionary`.
DictionaryStopwordFilter.Builder
Fluent builder for `DictionaryStopwordFilter`.
DigitCharSequenceNormalizer
A `CharSequenceNormalizer` that maps Unicode decimal digits to their ASCII equivalents, so for example Arabic-Indic, Devanagari, or fullwidth digits all become `0`-`9`.
Dimension
A layer of the `Term` normalization stack, in increasing order of aggressiveness.
DoccatCrossValidator
Cross validator for `DocumentCategorizer`.
DoccatFactory
The factory that provides Doccat default implementations and resources.
DoccatModel
A model for document categorization
DocumentBeginFeatureGenerator
This feature generator creates document begin features.
DocumentBeginFeatureGeneratorFactory
A `GeneratorFactory` that produces `DocumentBeginFeatureGenerator` instances when `DocumentBeginFeatureGeneratorFactory.create()` is called.
DocumentCategorizerEvaluator
The `DocumentCategorizerEvaluator` measures the performance of the given `DocumentCategorizer` with the provided reference `samples`.
DocumentCategorizerEventStream
Iterator-like class for modeling document classification events.
DocumentCategorizerME
A Max-Ent based implementation of `DocumentCategorizer`.
DocumentSampleStream
Reads in string encoded training samples, parses them and outputs `DocumentSample` objects.
DownloadUtil
This class facilitates the downloading of pretrained OpenNLP models.
dutchStemmer
This class implements the stemming algorithm defined by a snowball script.
EllipsisCharSequenceNormalizer
A `CharSequenceNormalizer` that expands the ellipsis and leader characters to ASCII dots: the horizontal ellipsis (`U+2026`) to `"..."` and the two-dot leader (`U+2025`) to `".."`.
EmojiAnnotation
The annotation record of one emoji: an extensible per-symbol store of attribute values, each carrying its own provenance.
EmojiAnnotation.Value
One attribute value with its provenance, mirroring one row of the bundled data file.
EmojiAnnotationFeatureGenerator
Generates features from the emoji annotation layer for the token at the given index: the project-authored coarse sentiment score (`emojiSentiment=2`), the entity type (`emojiType=HEART`), the document category (`emojiCategory=SMILEYS_AND_EMOTION`), and for flags the ISO 3166 region (`emojiRegion=DE`).
EmojiAnnotationFeatureGeneratorFactory
A `GeneratorFactory` that produces `EmojiAnnotationFeatureGenerator` instances when `EmojiAnnotationFeatureGeneratorFactory.create()` is called, for use in a feature generation descriptor:
EmojiAnnotationJoin
The joined-facts layer of the emoji annotation record store: a hook through which facts that live in user-installed data, typically a gazetteer (coordinates, containment chain, GeoNames or Who's On First identifiers), are resolved at run time and merged into an `EmojiAnnotation`.
EmojiAnnotations
The bundled-facts layer of the emoji annotation record store: license-clean, provenance-tagged attributes intrinsic to a pictograph (name, coarse sentiment, entity type, document category), loaded once from the project-authored `emoji-annotations.txt` resource.
EmojiAnnotator
Assembles one `EmojiAnnotation` per symbol from bundled facts (`EmojiAnnotations`), derived facts (`EmojiFlags`), and optional joined facts (`EmojiAnnotationJoin`).
EmojiCategory
The document-category hint of an annotated emoji, one constant per group header of the upstream Unicode `emoji-test.txt` (Emoji Keyboard/Display Test Data for UTS #51).
EmojiCharSequenceNormalizer
Deprecated, for removal: This API element is subject to removal in a future version.
Replaces every supplementary-plane code point with a space, not only emoji.
EmojiEntityType
The coarse entity type of an annotated emoji, a small project-authored taxonomy assigned from the subgroup headers of the upstream Unicode `emoji-test.txt` (Emoji Keyboard/Display Test Data for UTS #51): for example the `face-smiling` and `face-concerned` subgroups map to `EmojiEntityType.FACE` and `transport-ground` maps to `EmojiEntityType.VEHICLE`.
EmojiFeatureGenerator
Generates document features from the emoji annotation layer: for every annotated token the project-authored coarse sentiment score (`emojiSentiment=2`), the entity type (`emojiType=HEART`), the document category hint (`emojiCategory=SMILEYS_AND_EMOTION`), and for flags the ISO 3166 region (`emojiRegion=DE`).
EmojiFlags
The derived-facts layer of the emoji annotation record store: decodes flag emoji to ISO 3166 codes purely from the code point sequence, with no data file.
EmojiSentimentContextGenerator
A `SentimentContextGenerator` that adds emoji annotation features to the default token context: for every annotated token the project-authored coarse sentiment score (`emojiSentiment=2`), the entity type (`emojiType=HEART`), the category (`emojiCategory=SMILEYS_AND_EMOTION`), and for flags the region (`emojiRegion=DE`).
EmojiSentimentFactory
A `SentimentFactory` whose context generator adds emoji annotation features (see `EmojiSentimentContextGenerator`).
EmojiToEmoticonCharSequenceNormalizer
A `CharSequenceNormalizer` that folds emoji to ASCII emoticons, using the bundled `emoji-emoticons.txt` mapping (for example U+1F642 SLIGHTLY SMILING FACE to `:)`).
EmoticonToEmojiCharSequenceNormalizer
A `CharSequenceNormalizer` that folds ASCII emoticons to emoji, using the bundled `emoji-emoticons.txt` mapping (for example `:-)` to U+1F642 SLIGHTLY SMILING FACE).
EmptyLinePreprocessorStream
`ObjectStream` to clean up empty lines for empty line separated document streams.
- Skips empty line at training data start
- Transforms multiple empty lines in a row into one
- Replaces white space lines with empty lines
- TODO: Terminates last document with empty line if it is missing
This stream should be used by the components that mark empty lines to mark document boundaries.
englishStemmer
This class implements the stemming algorithm defined by a snowball script.
EntityLinkerFactory
Generates a `EntityLinker` instances via a `properties` file configuration.
Entry
An `Entry` is a `StringList` which can optionally be mapped to attributes.
EntryInserter
Evaluator<T>
An abstract base class for evaluators.
EventTraceStream
ExtendedPictographic
Checks the Unicode `Extended_Pictographic` property of a code point.
Factory
Factory
FeatureGeneratorUtil
This class provide common utilities for feature generation.
FilterObjectStream<S,T>
Abstract base class for filtering `streams`.
finnishStemmer
This class implements the stemming algorithm defined by a snowball script.
frenchStemmer
This class implements the stemming algorithm defined by a snowball script.
FullCaseFoldCharSequenceNormalizer
A `CharSequenceNormalizer` that applies Unicode full case folding for case-insensitive matching, as defined by the Default Case Algorithms in Section 3.13 of the Unicode Standard, using the bundled `CaseFolding.txt` data of the Unicode Character Database.
GeneratorFactory
Creates a set of feature generators based on a provided XML descriptor.
GeneratorFactory.AbstractXmlFeatureGeneratorFactory
GenericModelSerializer
An `ArtifactSerializer` implementation for `models`.
germanStemmer
This class implements the stemming algorithm defined by a snowball script.
GermanUmlautCharSequenceNormalizer
A `CharSequenceNormalizer` that transliterates German umlauts and the eszett the way German conventionally expands them (DIN 5007-2): a-umlaut to `ae`, o-umlaut to `oe`, u-umlaut to `ue`, and eszett to `ss`, with the capital umlauts and the capital eszett (U+1E9E) expanded likewise.
Glove
GloVe is an unsupervised learning algorithm for obtaining vector representations for words.
greekStemmer
This class implements the stemming algorithm defined by a snowball script.
HeadRules
Class for storing the English `HeadRules` associated with parsing.
HeadRules.HeadRulesSerializer
HMStringInterner
A `StringInterner` implementation based on `HashMap` by Aleksey Shipilëv.
hungarianStemmer
This class implements the stemming algorithm defined by a snowball script.
Index
This classes indexes `string lists`.
indonesianStemmer
This class implements the stemming algorithm defined by a snowball script.
InSpanGenerator
Generates features if the tokens are recognized by the provided `TokenNameFinder`.
InvisibleCharSequenceNormalizer
A `CharSequenceNormalizer` that removes invisible format and bidirectional control characters that add no textual content and are a common source of noise and spoofing (the byte-order mark, zero width space, word joiner, bidi marks/embeddings/overrides/isolates, the invisible math operators, soft hyphen, and the Arabic letter mark).
irishStemmer
This class implements the stemming algorithm defined by a snowball script.
italianStemmer
This class implements the stemming algorithm defined by a snowball script.
JvmStringInterner
A `StringInterner` implementation based on `String.intern()`.
LanguageDetectorConfig
LanguageDetectorCrossValidator
Cross validator for `LanguageDetector`.
LanguageDetectorEvaluator
The `LanguageDetectorEvaluator` measures the performance of the given `LanguageDetector` with the provided reference `LanguageSample`s.
LanguageDetectorEventStream
Iterator-like class for modeling an event stream of `samples`.
LanguageDetectorFactory
Default factory used by `LanguageDetector`.
LanguageDetectorME
Implements a learnable `LanguageDetector`.
LanguageDetectorModel
The `LanguageDetectorModel` is the model used by a learnable `LanguageDetector`.
LanguageDetectorSampleStream
This class reads in string encoded `training samples`, parses them and outputs `LanguageSample` objects.
LastResultOwnerOrThreadLocal<T>
Stores a per-thread "last result" value for APIs that expose probabilities or other data from the most recent decode call (e.g.
LemmaSampleEventStream
Class for creating an event stream out of data files for training a probabilistic `Lemmatizer`.
LemmaSampleSequenceStream
A `SequenceStream` implementation encapsulating `samples`.
LemmaSampleStream
Reads data for training and testing the `Lemmatizer`.
LemmatizerEvaluator
The `LemmatizerEvaluator` measures the performance of the given `Lemmatizer` with the provided reference `samples`.
LemmatizerFactory
The factory that provides `Lemmatizer` default implementation and resources.
LemmatizerME
A probabilistic `Lemmatizer` implementation.
LemmatizerModel
The `LemmatizerModel` is the model used by a learnable `Lemmatizer`.
LineBreakPreservingWhitespaceCharSequenceNormalizer
An `OffsetAwareNormalizer` that collapses runs of Unicode whitespace like `WhitespaceCharSequenceNormalizer`, but keeps line and paragraph structure: any whitespace run that contains a line break collapses to a single newline (`U+000A`) instead of a space, and leading and trailing whitespace is trimmed.
LogPrintStream
This class serves as an adapter for a `Logger` used within a `PrintStream`.
ModelUtil
Utility class for handling of `models`.
MutableInt
This is a non-thread safe mutable int.
NameFinderEventStream
Class for creating an event stream out of data files for training an `TokenNameFinder`.
NameFinderME
A maximum-entropy-based `name finder` implementation.
NameFinderSequenceValidator
The default name finder `SequenceValidator` implementation.
NameSampleDataStream
The `NameSampleDataStream` class converts tagged tokens provided by a DataStream to `NameSample` objects.
NameSampleSequenceStream
A `SequenceStream` implementation encapsulating `samples`.
NameSampleTypeFilter
A `stream` which removes `name samples` which do not have a certain type.
NewlineSentenceDetector
The Newline `SentenceDetector` assumes that sentences are line delimited and recognizes one sentence per non-empty line.
NfcCharSequenceNormalizer
A `CharSequenceNormalizer` that applies Unicode Normalization Form C (canonical composition, UAX #15).
NfkcCharSequenceNormalizer
A `CharSequenceNormalizer` that applies Unicode Normalization Form KC (compatibility composition, UAX #15).
NGramCharModel
The `NGramCharModel` can be used to create character ngrams.
NGramFeatureGenerator
Generates ngram features for a document.
NGramGenerator
Generates an nGram, via an optional separator, and returns the grams as a list of strings
NGramLanguageModel
A `LanguageModel` based on a `NGramModel` using Stupid Backoff to get the probabilities of the ngrams.
NGramModel
The `NGramModel` can be used to crate ngrams and character ngrams.
NGramUtils
Utility class for ngrams.
NoOpStringInterner
A no-op `StringInterner` implementation, which does not intern.
NormalizationProfile
Per-language normalization settings, mirroring how OpenNLP already selects a Snowball stemmer by language.
NormalizationProfiles
A registry of `NormalizationProfile`s by language, with detection-based fallback.
norwegianStemmer
This class implements the stemming algorithm defined by a snowball script.
NumberCharSequenceNormalizer
A `CharSequenceNormalizer` implementation that normalizes text in terms of numbers: every maximal run of ASCII digits (`0` to `9`), that is the longest unbroken stretch of consecutive digits, is replaced by a single space.
OutcomePriorFeatureGenerator
The definition feature maps the underlying distribution of outcomes.
OwnerOrPerThreadState<S>
Routes mutable per-invocation state either to a single owner-thread field or to `ThreadLocal` storage once multiple threads use the same enclosing instance.
Parser
A shift reduce style `Parser` implementation based on Adwait Ratnaparkhi's 1998 thesis.
Parser
A built-attach `Parser` implementation.
ParserChunkerFactory
ParserChunkerSequenceValidator
The parser chunker `SequenceValidator` implementation.
ParserEventStream
Wrapper class for one of four `shift-reduce parser` event streams.
ParserEventStream
Wrapper class for one of four `built-attach parser` event streams.
ParserFactory
ParserModel
This is the default `ParserModel` implementation.
ParseSampleStream
porterStemmer
This class implements the stemming algorithm defined by a snowball script.
PorterStemmer
A `Stemmer`, implementing the Porter Stemming Algorithm
PorterStemmerFactory
A thread-safe factory for `PorterStemmer` instances.
portugueseStemmer
This class implements the stemming algorithm defined by a snowball script.
POSDictionary
Provides a means of determining which tags are valid for a particular word based on a `TagDictionary` read from a file.
POSEvaluator
The `POSEvaluator` measures the performance of the given `POSTagger` with the provided reference `samples`.
POSModel
The `POSModel` is the model used by a learnable `POSTagger`.
POSModelSerializer
An `ArtifactSerializer` implementation for `models`.
POSSampleEventStream
Reads the `samples` from an `Iterator` and converts those samples into `events` which can be used by the maxent library for training.
POSSampleSequenceStream
A `SequenceStream` implementation encapsulating `samples`.
PosSampleStream
POSTagFormat
Defines the format for part-of-speech tagging, i.e.
POSTagFormatMapper
A mapping implementation for converting between different POS tag formats.
POSTagFormatMapper.NoOp
POSTaggerCrossValidator
POSTaggerFactory
The factory that provides `POSTagger` default implementations and resources.
POSTaggerFactory.POSDictionarySerializer
PosTaggerFeatureGenerator
A POS tagging driven feature generator.
PosTaggerFeatureGeneratorFactory
A `GeneratorFactory` that produces `PosTaggerFeatureGenerator` instances when `PosTaggerFeatureGeneratorFactory.create()` is called.
POSTaggerME
A `part-of-speech tagger` implementation that uses maximum entropy.
POSTaggerNameFeatureGenerator
Adds the token POS tag as feature.
POSTaggerNameFeatureGeneratorFactory
A `GeneratorFactory` that produces `POSTaggerNameFeatureGenerator` instances when `POSTaggerNameFeatureGeneratorFactory.create()` is called.
PrefixFeatureGenerator
A feature generator implementation that generates prefix-based features.
PrefixFeatureGeneratorFactory
A `GeneratorFactory` that produces `PrefixFeatureGenerator` instances when `PrefixFeatureGeneratorFactory.create()` is called.
PreviousMapFeatureGenerator
This `AdaptiveFeatureGenerator` generates features indicating the outcome associated with a previously occurring word.
PreviousMapFeatureGeneratorFactory
A `GeneratorFactory` that produces `PreviousMapFeatureGenerator` instances when `PreviousMapFeatureGeneratorFactory.create()` is called.
PreviousTwoMapFeatureGenerator
This `AdaptiveFeatureGenerator` generates features indicating the outcome associated with two previously occurring words.
ProbingLanguageDetectionResult
A data container encapsulating language detection results.
QuoteCharSequenceNormalizer
A `CharSequenceNormalizer` that folds typographic quotation marks to their ASCII forms: the single quotes and apostrophes to `'` and the double quotes to `"`.
RegexNameFinder
A `TokenNameFinder` implementation based on a series of regular expressions.
RegexNameFinderFactory
Returns a `RegexNameFinder` based on a selection of defaults or a configuration and a selection of defaults.
RegexNameFinderFactory.DEFAULT_REGEX_NAME_FINDER
Enumeration of typical regex expressions available in OpenNLP.
RegexNameFinderFactory.RegexAble
romanianStemmer
This class implements the stemming algorithm defined by a snowball script.
russianStemmer
This class implements the stemming algorithm defined by a snowball script.
SDCrossValidator
A cross validator for `sentence detectors`.
SDEventStream
SentenceContextGenerator
Creates contexts/features for end-of-sentence detection in Thai text.
SentenceDetectorEvaluator
The `SentenceDetectorEvaluator` measures the performance of the given `SentenceDetector` with the provided reference `SentenceSample`s.
SentenceDetectorFactory
The factory that provides `SentenceDetector` default implementations and resources
SentenceDetectorME
A sentence detector for splitting up raw text into sentences.
SentenceFeatureGenerator
This feature generator creates sentence begin and end features.
SentenceFeatureGeneratorFactory
A `GeneratorFactory` that produces `SentenceFeatureGenerator` instances when `SentenceFeatureGeneratorFactory.create()` is called.
SentenceModel
The `SentenceModel` is the model used by a learnable `SentenceDetector`.
SentenceSampleStream
This class is a stream filter which reads a sentence by line samples from an `ObjectStream` and converts them into `SentenceSample` objects.
SentimentContextGenerator
Class for using a Context Generator for Sentiment Analysis.
SentimentCrossValidator
Class for performing cross validation on the Sentiment Analysis Parser.
SentimentEvaluator
The `SentimentEvaluator` measures the performance of the given `SentimentME` with the provided reference `SentimentSample`s.
SentimentEventStream
Class for creating events for Sentiment Analysis that is later sent to MaxEnt.
SentimentFactory
Class for creating sentiment factories for training.
SentimentME
A `SentimentDetector` implementation for creating and using maximum-entropy-based Sentiment Analysis models.
SentimentModel
Class for the basis of the Sentiment Analysis model.
SentimentSampleStream
Class for converting Strings through Data Stream to `SentimentSample` using tokenised text.
SentimentSampleTypeFilter
Class for creating a type filter.
SharingStemmer
A `Stemmer` that is safe to share across threads by routing each call to a per-thread delegate minted from a `StemmerFactory`.
ShrinkCharSequenceNormalizer
A `CharSequenceNormalizer` implementation that shrinks repeated whitespace and repeated characters in text, in three steps: Each run of two or more ASCII whitespace characters (tab, line feed, vertical tab, form feed, carriage return, or space) collapses to a single space.
SimpleTokenizer
A basic `Tokenizer` implementation which performs tokenization using character classes.
SnowballProgram
Base class for a snowball stemmer
SnowballStemmer
A `Stemmer` backed by the generated Snowball engines.
SnowballStemmer.ALGORITHM
SnowballStemmerFactory
A thread-safe factory that captures a Snowball stemmer configuration for APIs that accept a `StemmerFactory`.
SocialMediaCharSequenceNormalizer
A `CharSequenceNormalizer` implementation that normalizes social media text: hashtags, user handles, retweet markers, emoticons, and repeated laughter.
spanishStemmer
This class implements the stemming algorithm defined by a snowball script.
StopwordFilteringTokenizer
A `Tokenizer` decorator which delegates tokenization to a wrapped `Tokenizer` and then removes any tokens identified as stopwords by the supplied `StopwordFilter`.
StopwordFilterStream
A `FilterObjectStream` which removes stopwords from each `String[]` sample produced by an underlying `ObjectStream<String[]>`.
StopwordLists
Static factory for `StopwordFilter` instances backed by bundled language-specific stopword resources or caller-supplied input streams.
StringInterners
Provides string interning utility methods.
StringList
A `StringList` is an immutable list of `String`s.
StringPattern
Recognizes predefined patterns in strings.
SuffixFeatureGenerator
A feature generator implementation that generates suffix-based features.
SuffixFeatureGeneratorFactory
A `GeneratorFactory` that produces `SuffixFeatureGenerator` instances when `SuffixFeatureGeneratorFactory.create()` is called.
swedishStemmer
This class implements the stemming algorithm defined by a snowball script.
Term
One token as a stack of normalization layers.
TermAnalyzer
Builds `Term`s by segmenting text and applying a configured stack of normalization `Dimension`s to each token.
TermAnalyzer.Builder
A builder for `TermAnalyzer`.
TextNormalizer
Entry point for composing normalization steps into a single `CharSequenceNormalizer`.
TextNormalizer.Builder
A fluent builder that appends normalization steps in order and composes them into one `CharSequenceNormalizer` via `TextNormalizer.Builder.build()`.
ThreadSafeChunkerME
Deprecated.
As of OPENNLP-1816, `ChunkerME` is itself thread-safe.
ThreadSafeLanguageDetectorME
Deprecated.
As of OPENNLP-1816, `LanguageDetectorME` is itself thread-safe.
ThreadSafeLemmatizerME
Deprecated.
As of OPENNLP-1816, `LemmatizerME` is itself thread-safe.
ThreadSafeNameFinderME
Deprecated.
As of OPENNLP-1816, `NameFinderME` is itself thread-safe.
ThreadSafePOSTaggerME
Deprecated.
As of OPENNLP-1816, `POSTaggerME` is itself thread-safe.
ThreadSafeSentenceDetectorME
Deprecated.
As of OPENNLP-1816, `SentenceDetectorME` is itself thread-safe.
ThreadSafeTokenizerME
Deprecated.
As of OPENNLP-1816, `TokenizerME` is itself thread-safe.
TokenClassFeatureGenerator
Generates features for the class of a token.
TokenClassFeatureGeneratorFactory
A `GeneratorFactory` that produces `TokenClassFeatureGenerator` instances when `TokenClassFeatureGeneratorFactory.create()` is called.
TokenFeatureGenerator
Generates a feature which contains a token itself.
TokenFeatureGeneratorFactory
A `GeneratorFactory` that produces `TokenFeatureGenerator` instances when `TokenFeatureGeneratorFactory.create()` is called.
TokenizerCrossValidator
A cross validator for `tokenizers`.
TokenizerEvaluator
The `TokenizerEvaluator` measures the performance of the given `Tokenizer` with the provided reference `samples`.
TokenizerFactory
The factory that provides `Tokenizer` default implementation and resources.
TokenizerME
A `Tokenizer` for converting raw text into separated tokens.
TokenizerModel
The `TokenizerModel` is the model used by a learnable `Tokenizer`.
TokenizerStream
The `TokenizerStream` uses a `Tokenizer` to tokenize the input string and output `samples`.
TokenNameFinderCrossValidator
Cross validator for `TokenNameFinder`.
TokenNameFinderEvaluator
The `TokenNameFinderEvaluator` measures the performance of the given `TokenNameFinder` with the provided reference `samples`.
TokenNameFinderFactory
The factory that provides `TokenNameFinder` default implementations and resources.
TokenNameFinderModel
The `TokenNameFinderModel` is the model used by a learnable `TokenNameFinder`.
TokenNameFinderModel.FeatureGeneratorCreationError
TokenPatternFeatureGenerator
Partitions tokens into sub-tokens based on character classes and generates class features for each of the sub-tokens and combinations of those sub-tokens.
TokenPatternFeatureGeneratorFactory
A `GeneratorFactory` instantiates `TokenPatternFeatureGenerator` instances when `TokenPatternFeatureGeneratorFactory.create()` is called.
TokenSampleStream
Class which produces an Iterator<TokenSample> from a file of space delimited token.
TokenSampleStream
This class is a `stream filter` which reads in string encoded samples and creates `samples` out of them.
TokSpanEventStream
This class reads the `samples` via an `Iterator` and converts the samples into `events` which can be used by the maxent library for training.
TrainerFactory
A factory to initialize `Trainer` instances depending on a trainer type configured via `Parameters`.
TrainerFactory.TrainerType
TrigramNameFeatureGenerator
Adds trigram features based on tokens and token classes.
TrigramNameFeatureGeneratorFactory
A `GeneratorFactory` that produces `TrigramNameFeatureGenerator` instances when `TrigramNameFeatureGeneratorFactory.create()` is called.
turkishStemmer
This class implements the stemming algorithm defined by a snowball script.
UncloseableInputStream
An `InputStream` which cannot be closed.
UrlCharSequenceNormalizer
A `CharSequenceNormalizer` implementation that normalizes text in terms of URls and email addresses.
Version
The `Version` class represents the OpenNLP Tools library version.
WhitespaceCharSequenceNormalizer
A `CharSequenceNormalizer` that collapses each run of Unicode whitespace to a single ASCII space and trims the edges, reusing the cursor based `CharClass.whitespace()` engine.
WhitespaceTokenStream
This stream formats `ObjectStream` of `samples` into whitespace separated token strings.
WindowFeatureGenerator
Generates previous (left-sided) and next (right-sided) features for a given `AdaptiveFeatureGenerator`.
WindowFeatureGeneratorFactory
A `GeneratorFactory` that produces `WindowFeatureGenerator` instances when `WindowFeatureGeneratorFactory.create()` is called.
WordBreak
The Unicode `Word_Break` property values, used by the UAX #29 word boundary algorithm.
WordBreakProperty
Looks up the Unicode `Word_Break` property of a code point.
WordClusterDictionary
WordClusterDictionary.WordClusterDictionarySerializer
WordClusterFeatureGenerator
An `AdaptiveFeatureGenerator` implementation of a word cluster feature generator.
WordClusterFeatureGeneratorFactory
Defines a word cluster `GeneratorFactory`; it reads an element containing 'w2vwordcluster' as a tag name.
WordSegmenter
Finds word boundaries in text using the Unicode Text Segmentation algorithm (UAX #29), rules WB1 through WB999.
WordSegmenter.SegmentConsumer
Receives each word segment as the half-open character range `[start, end)`.
WordTagSampleStream
A `stream filter` which reads a sentence per line that contains words and tags in `word_tag` format and outputs a `POSSample` objects.
WordToken
A word token produced by `WordTokenizer`: the character `Span` into the source text together with its `WordType`.
WordTokenizer
A word tokenizer built on the Unicode Text Segmentation algorithm (UAX #29).
WordTokenizer.TokenHandler
Receives each word token as a character range and its type, with no allocation.
WordType
The category of a word token.
XmlUtil