Module org.apache.lucene.analysis.common

Package org.apache.lucene.analysis.hunspell

Class Dictionary

java.lang.Object

org.apache.lucene.analysis.hunspell.Dictionary

public class Dictionary
extends Object

In-memory structure for the dictionary (.dic) and affix (.aff) data of a hunspell dictionary.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	Dictionary.Breaks	Possible word breaks according to BREAK directives
private static class	Dictionary.DefaultAsUtf8FlagParsingStrategy	Used to read flags as UTF-8 even if the rest of the file is in the default (8-bit) encoding
private static class	Dictionary.DoubleASCIIFlagParsingStrategy	Implementation of Dictionary.FlagParsingStrategy that assumes each flag is encoded as two ASCII characters whose codes must be combined into a single character.
(package private) static class	Dictionary.FlagParsingStrategy	Abstraction of the process of parsing flags taken from the affix and dic files
private static class	Dictionary.NumFlagParsingStrategy	Implementation of Dictionary.FlagParsingStrategy that assumes each flag is encoded in its numerical form.
private static class	Dictionary.SimpleFlagParsingStrategy	Simple implementation of Dictionary.FlagParsingStrategy that treats the chars in each String as a individual flags.

Field Summary

Fields

Modifier and Type	Field	Description
(package private) static final int	AFFIX_APPEND
private static final int	AFFIX_CONDITION
(package private) static final int	AFFIX_FLAG
(package private) static final int	AFFIX_STRIP_ORD
(package private) char[]	affixData
private int	aliasCount
private String[]	aliases
private boolean	alternateCasing
private static final byte[]	BOM_UTF8
(package private) Dictionary.Breaks	breaks
(package private) static final Map<String,String>	CHARSET_ALIASES
(package private) boolean	checkCompoundCase
(package private) boolean	checkCompoundDup
(package private) List<CheckCompoundPattern>	checkCompoundPatterns
(package private) boolean	checkCompoundRep
(package private) boolean	checkCompoundTriple
(package private) boolean	checkSharpS
(package private) char	circumfix
(package private) boolean	complexPrefixes
(package private) char	compoundBegin
(package private) char	compoundEnd
(package private) char	compoundFlag
(package private) char	compoundForbid
(package private) int	compoundMax
(package private) char	compoundMiddle
(package private) int	compoundMin
(package private) char	compoundPermit
(package private) CompoundRule[]	compoundRules
private int	currentAffix
(package private) CharsetDecoder	decoder
(package private) static final Charset	DEFAULT_CHARSET
private static final int	DEFAULT_FLAGS
(package private) boolean	enableSplitSuggestions
private static final char	FLAG_SEPARATOR
(package private) static final char	FLAG_UNSET
(package private) final FlagEnumerator.Lookup	flagLookup	The list of unique flagsets (wordforms).
(package private) Dictionary.FlagParsingStrategy	flagParsingStrategy
(package private) char	forbiddenword
(package private) char	forceUCase
(package private) boolean	fullStrip
(package private) boolean	hasCustomMorphData	we set this during sorting, so we know to add an extra int (index in morphData) to FST output
(package private) static final char	HIDDEN_FLAG
(package private) ConvTable	iconv
private char[]	ignore
(package private) boolean	ignoreCase
(package private) char	keepcase
(package private) String	language
(package private) List<List<String>>	mapTable
(package private) static final int	MAX_PROLOGUE_SCAN_WINDOW
(package private) int	maxDiff
(package private) int	maxNGramSuggestions
private static final char	MORPH_SEPARATOR
private int	morphAliasCount
private String[]	morphAliases
(package private) final List<String>	morphData
(package private) char	needaffix
(package private) String[]	neighborKeyGroups
(package private) static final char[]	NOFLAGS
(package private) char	noSuggest
(package private) ConvTable	oconv
(package private) char	onlyincompound
(package private) boolean	onlyMaxDiff
(package private) ArrayList<AffixCondition>	patterns	All condition checks used by prefixes and suffixes.
(package private) FST<IntsRef>	prefixes
(package private) List<RepEntry>	repTable
private char[]	secondStagePrefixFlags	All flags used in affix continuation classes.
private char[]	secondStageSuffixFlags	All flags used in affix continuation classes.
(package private) boolean	simplifiedTriple
(package private) char[]	stripData
(package private) int[]	stripOffsets
(package private) char	subStandard
(package private) FST<IntsRef>	suffixes
(package private) String	tryChars
(package private) String	wordChars
(package private) WordStorage	words	The entries in the .dic file, mapping to their set of flags

Constructor Summary

Constructors

Constructor	Description
Dictionary(InputStream affix, List<InputStream> dictionaries, boolean ignoreCase, SortingStrategy sortingStrategy)	Creates a new Dictionary containing the information read from the provided InputStreams to hunspell affix and dictionary files.
Dictionary(Directory tempDir, String tempFileNamePrefix, InputStream affix, InputStream dictionary)	Creates a new Dictionary containing the information read from the provided InputStreams to hunspell affix and dictionary files.
Dictionary(Directory tempDir, String tempFileNamePrefix, InputStream affix, List<InputStream> dictionaries, boolean ignoreCase)	Creates a new Dictionary containing the information read from the provided InputStreams to hunspell affix and dictionary files.

Method Summary

Modifier and Type	Method	Description
private void	addHiddenCapitalizedWord(StringBuilder reuse, SortingStrategy.EntryAccumulator acc, String word, String afterSep)
private int	addMorphFields(Map<String,Integer> indices, String morphFields)
private void	addPhoneticRepEntries(String word, String ph)
(package private) char	affixData(int affixIndex, int offset)
private FST<IntsRef>	affixFST(TreeMap<String,IntArrayList> affixes)
(package private) char[]	allNonSuggestibleFlags()
(package private) char	caseFold(char c)	folds single character (according to LANG if present)
private void	checkCriticalDirectiveSame(String directive, LineNumberReader reader, Object expected, Object actual)
(package private) CharSequence	cleanInput(CharSequence input, StringBuilder reuse)
(package private) DictEntry	dictEntry(String root, int flagId, int morphDataId)
(package private) static String	extractLanguageCode(String isoCode)
private String	firstArgument(LineNumberReader reader, String line)
(package private) int	formStep()
(package private) int	getAffixCondition(int affix)
private String	getAliasValue(int id)
private CharsetDecoder	getDecoder(String encoding)	Retrieves the CharsetDecoder for the given encoding.
(package private) static Path	getDefaultTempDir()	Returns the default temporary directory pointed to by java.io.tmpdir.
(package private) static Dictionary.FlagParsingStrategy	getFlagParsingStrategy(String flagLine, Charset charset)	Determines the appropriate Dictionary.FlagParsingStrategy based on the FLAG definition line taken from the affix file
boolean	getIgnoreCase()	Returns true if this dictionary was constructed with the ignoreCase option
(package private) boolean	hasFlag(int entryId, char flag)
(package private) boolean	hasFlag(IntsRef forms, char flag)
protected double	hashFactor()	The factor determining the size of the internal hash table used for storing the entries.
(package private) boolean	hasLanguage(String... langCodes)
(package private) static int	indexOfSpaceOrTab(String text, int start)
(package private) boolean	isCrossProduct(int affix)
(package private) boolean	isDotICaseChangeDisallowed(char[] word)
(package private) boolean	isFlagAppendedByAffix(int affixId, char flag)
(package private) boolean	isSecondStagePrefix(char flag)
(package private) boolean	isSecondStageSuffix(char flag)
private IntsRef	lookup(FST<IntsRef> fst, char[] word)
DictEntries	lookupEntries(String root)
(package private) IntsRef	lookupPrefix(char[] word)
(package private) IntsRef	lookupSuffix(char[] word)
(package private) IntsRef	lookupWord(char[] word, int offset, int length)	Looks up Hunspell word forms from the dictionary
private static boolean	maybeConsume(BufferedInputStream stream, byte[] bytes)	Consume the provided byte sequence in full, if present.
(package private) boolean	mayNeedInputCleaning()
private void	mergeDictionaries(List<InputStream> dictionaries, CharsetDecoder decoder, SortingStrategy.EntryAccumulator acc)
private static int	morphBoundary(String line)
(package private) boolean	needsInputCleaning(CharSequence input)
(package private) static IntsRef	nextArc(FST<IntsRef> fst, FST.Arc<IntsRef> arc, FST.BytesReader reader, IntsRef output, int ch)
private void	parseAffix(TreeMap<String,IntArrayList> affixes, CharHashSet secondStageFlags, String header, LineNumberReader reader, AffixKind kind, Map<String,Integer> seenPatterns, Map<String,Integer> seenStrips, FlagEnumerator flags)	Parses a specific affix rule putting the result into the provided affix map
private void	parseAlias(String line)
private Dictionary.Breaks	parseBreaks(LineNumberReader reader, String line)
private CompoundRule[]	parseCompoundRules(LineNumberReader reader, int num)
private ConvTable	parseConversions(LineNumberReader reader, int num)
private List<String>	parseMapEntry(LineNumberReader reader, String line)
private void	parseMorphAlias(String line)
private int	parseNum(LineNumberReader reader, String line)
private void	readAffixFile(InputStream affixStream, CharsetDecoder decoder, FlagEnumerator flags)	Reads the affix file through the provided InputStream, building up the prefix and suffix maps
private void	readConfig(InputStream stream, Charset streamCharset)	Parses the encoding and flag format specified in the provided InputStream
private List<String>	readMorphFields(String word, String unparsed)
private WordStorage	readSortedDictionaries(FlagEnumerator flags, SortingStrategy.EntrySupplier sorted)
private static CharsetDecoder	replacingDecoder(Charset charset)
private static boolean	shouldSkipEscapedChar(char ch)
private String	singleArgument(LineNumberReader reader, String line)
private String[]	splitBySpace(LineNumberReader reader, String line, int expectedParts)
private String[]	splitBySpace(LineNumberReader reader, String line, int minParts, int maxParts)
private List<String>	splitMorphData(String morphData)
protected boolean	tolerateAffixRuleCountMismatches()	Whether incorrect PFX/SFX rule counts should be silently ignored.
protected boolean	tolerateDuplicateConversionMappings()	Whether duplicate ICONV/OCONV lines should be silently ignored.
(package private) String	toLowerCase(String word)
(package private) static char[]	toSortedCharArray(CharHashSet set)
(package private) String	toTitleCase(String word)
private String	unescapeEntry(String entry)
private void	writeNormalizedWordEntry(StringBuilder reuse, String line, SortingStrategy.EntryAccumulator acc)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

MAX_PROLOGUE_SCAN_WINDOW

static final int MAX_PROLOGUE_SCAN_WINDOW

See Also:

• Constant Field Values

NOFLAGS

static final char[] NOFLAGS

FLAG_UNSET

static final char FLAG_UNSET

See Also:

• Constant Field Values

DEFAULT_FLAGS

private static final int DEFAULT_FLAGS

See Also:

• Constant Field Values

HIDDEN_FLAG

static final char HIDDEN_FLAG

See Also:

• Constant Field Values

DEFAULT_CHARSET

static final Charset DEFAULT_CHARSET

decoder

CharsetDecoder decoder

prefixes

FST<IntsRef> prefixes

suffixes

FST<IntsRef> suffixes

breaks

Dictionary.Breaks breaks

patterns

ArrayList<AffixCondition> patterns

All condition checks used by prefixes and suffixes. these are typically re-used across many affix stripping rules. so these are deduplicated, to save RAM.

words

WordStorage words

The entries in the .dic file, mapping to their set of flags

flagLookup

final FlagEnumerator.Lookup flagLookup

The list of unique flagsets (wordforms). theoretically huge, but practically small (for Polish this is 756), otherwise humans wouldn't be able to deal with it either.

stripData

char[] stripData

stripOffsets

int[] stripOffsets

wordChars

String wordChars

affixData

char[] affixData

currentAffix

private int currentAffix

AFFIX_FLAG

static final int AFFIX_FLAG

See Also:

• Constant Field Values

AFFIX_STRIP_ORD

static final int AFFIX_STRIP_ORD

See Also:

• Constant Field Values

AFFIX_CONDITION

private static final int AFFIX_CONDITION

See Also:

• Constant Field Values

AFFIX_APPEND

static final int AFFIX_APPEND

See Also:

• Constant Field Values

flagParsingStrategy

Dictionary.FlagParsingStrategy flagParsingStrategy

aliases

private String[] aliases

aliasCount

private int aliasCount

morphAliases

private String[] morphAliases

morphAliasCount

private int morphAliasCount

morphData

final List<String> morphData

hasCustomMorphData

boolean hasCustomMorphData

we set this during sorting, so we know to add an extra int (index in morphData) to FST output

ignoreCase

boolean ignoreCase

checkSharpS

boolean checkSharpS

complexPrefixes

boolean complexPrefixes

secondStagePrefixFlags

private char[] secondStagePrefixFlags

All flags used in affix continuation classes. If an outer affix's flag isn't here, there's no need to do 2-level affix stripping with it.

secondStageSuffixFlags

private char[] secondStageSuffixFlags

All flags used in affix continuation classes. If an outer affix's flag isn't here, there's no need to do 2-level affix stripping with it.

circumfix

char circumfix

keepcase

char keepcase

forceUCase

char forceUCase

needaffix

char needaffix

forbiddenword

char forbiddenword

onlyincompound

char onlyincompound

compoundBegin

char compoundBegin

compoundMiddle

char compoundMiddle

compoundEnd

char compoundEnd

compoundFlag

char compoundFlag

compoundPermit

char compoundPermit

compoundForbid

char compoundForbid

checkCompoundCase

boolean checkCompoundCase

checkCompoundDup

boolean checkCompoundDup

checkCompoundRep

boolean checkCompoundRep

checkCompoundTriple

boolean checkCompoundTriple

simplifiedTriple

boolean simplifiedTriple

compoundMin

int compoundMin

compoundMax

int compoundMax

compoundRules

CompoundRule[] compoundRules

checkCompoundPatterns

List<CheckCompoundPattern> checkCompoundPatterns

ignore

private char[] ignore

tryChars

String tryChars

neighborKeyGroups

String[] neighborKeyGroups

enableSplitSuggestions

boolean enableSplitSuggestions

repTable

List<RepEntry> repTable

mapTable

List<List<String>> mapTable

maxDiff

int maxDiff

maxNGramSuggestions

int maxNGramSuggestions

onlyMaxDiff

boolean onlyMaxDiff

noSuggest

char noSuggest

subStandard

char subStandard

iconv

ConvTable iconv

oconv

ConvTable oconv

fullStrip

boolean fullStrip

language

String language

alternateCasing

private boolean alternateCasing

BOM_UTF8

private static final byte[] BOM_UTF8

CHARSET_ALIASES

static final Map<String,String> CHARSET_ALIASES

FLAG_SEPARATOR

private static final char FLAG_SEPARATOR

See Also:

• Constant Field Values

MORPH_SEPARATOR

private static final char MORPH_SEPARATOR

See Also:

• Constant Field Values

Constructor Details

Dictionary

public Dictionary(Directory tempDir,
 String tempFileNamePrefix,
 InputStream affix,
 InputStream dictionary)
           throws IOException,
ParseException

Creates a new Dictionary containing the information read from the provided InputStreams to hunspell affix and dictionary files. You have to close the provided InputStreams yourself.

Parameters:

tempDir - Directory to use for offline sorting

tempFileNamePrefix - prefix to use to generate temp file names

affix - InputStream for reading the hunspell affix file (won't be closed).

dictionary - InputStream for reading the hunspell dictionary file (won't be closed).

Throws:

IOException - Can be thrown while reading from the InputStreams

ParseException - Can be thrown if the content of the files does not meet expected formats

Dictionary

public Dictionary(Directory tempDir,
 String tempFileNamePrefix,
 InputStream affix,
 List<InputStream> dictionaries,
 boolean ignoreCase)
           throws IOException,
ParseException

Creates a new Dictionary containing the information read from the provided InputStreams to hunspell affix and dictionary files. You have to close the provided InputStreams yourself.

Parameters:

tempDir - Directory to use for offline sorting

tempFileNamePrefix - prefix to use to generate temp file names

affix - InputStream for reading the hunspell affix file (won't be closed).

dictionaries - InputStream for reading the hunspell dictionary files (won't be closed).

Throws:

IOException - Can be thrown while reading from the InputStreams

ParseException - Can be thrown if the content of the files does not meet expected formats

Dictionary

public Dictionary(InputStream affix,
 List<InputStream> dictionaries,
 boolean ignoreCase,
 SortingStrategy sortingStrategy)
           throws IOException,
ParseException

Creates a new Dictionary containing the information read from the provided InputStreams to hunspell affix and dictionary files. You have to close the provided InputStreams yourself.

Parameters:

affix - InputStream for reading the hunspell affix file (won't be closed).

dictionaries - InputStream for reading the hunspell dictionary files (won't be closed).

sortingStrategy - the entry strategy for the dictionary loading

Throws:

IOException - Can be thrown while reading from the InputStreams

ParseException - Can be thrown if the content of the files does not meet expected formats

Method Details

formStep

int formStep()

lookupWord

IntsRef lookupWord(char[] word,
 int offset,
 int length)

Looks up Hunspell word forms from the dictionary

lookupPrefix

IntsRef lookupPrefix(char[] word)

lookupSuffix

IntsRef lookupSuffix(char[] word)

lookup

private IntsRef lookup(FST<IntsRef> fst,
 char[] word)

nextArc

static IntsRef nextArc(FST<IntsRef> fst,
 FST.Arc<IntsRef> arc,
 FST.BytesReader reader,
 IntsRef output,
 int ch)

readAffixFile

private void readAffixFile(InputStream affixStream,
 CharsetDecoder decoder,
 FlagEnumerator flags)
                    throws IOException,
ParseException

Reads the affix file through the provided InputStream, building up the prefix and suffix maps

Parameters:

affixStream - InputStream to read the content of the affix file from

decoder - CharsetDecoder to decode the content of the file

Throws:

IOException - Can be thrown while reading from the InputStream

ParseException

checkCriticalDirectiveSame

private void checkCriticalDirectiveSame(String directive,
 LineNumberReader reader,
 Object expected,
 Object actual)
                                 throws ParseException

Throws:

ParseException

parseMapEntry

private List<String> parseMapEntry(LineNumberReader reader,
 String line)
                            throws ParseException

Throws:

ParseException

hasLanguage

boolean hasLanguage(String... langCodes)

lookupEntries

public DictEntries lookupEntries(String root)

Parameters:

root - a string to look up in the dictionary. No case conversion or affix removal is performed. To get the possible roots of any word, you may call Hunspell.getRoots(String)

Returns:

the dictionary entries for the given root, or null if there's none

dictEntry

DictEntry dictEntry(String root,
 int flagId,
 int morphDataId)

extractLanguageCode

static String extractLanguageCode(String isoCode)

parseNum

private int parseNum(LineNumberReader reader,
 String line)
              throws ParseException

Throws:

ParseException

singleArgument

private String singleArgument(LineNumberReader reader,
 String line)
                       throws ParseException

Throws:

ParseException

firstArgument

private String firstArgument(LineNumberReader reader,
 String line)
                      throws ParseException

Throws:

ParseException

splitBySpace

private String[] splitBySpace(LineNumberReader reader,
 String line,
 int expectedParts)
                       throws ParseException

Throws:

ParseException

splitBySpace

private String[] splitBySpace(LineNumberReader reader,
 String line,
 int minParts,
 int maxParts)
                       throws ParseException

Throws:

ParseException

parseCompoundRules

private CompoundRule[] parseCompoundRules(LineNumberReader reader,
 int num)
                                   throws IOException,
ParseException

Throws:

IOException

ParseException

parseBreaks

private Dictionary.Breaks parseBreaks(LineNumberReader reader,
 String line)
                               throws IOException,
ParseException

Throws:

IOException

ParseException

affixFST

private FST<IntsRef> affixFST(TreeMap<String,IntArrayList> affixes)
                       throws IOException

Throws:

IOException

parseAffix

private void parseAffix(TreeMap<String,IntArrayList> affixes,
 CharHashSet secondStageFlags,
 String header,
 LineNumberReader reader,
 AffixKind kind,
 Map<String,Integer> seenPatterns,
 Map<String,Integer> seenStrips,
 FlagEnumerator flags)
                 throws IOException,
ParseException

Parses a specific affix rule putting the result into the provided affix map

Parameters:

affixes - Map where the result of the parsing will be put

header - Header line of the affix rule

reader - BufferedReader to read the content of the rule from

seenPatterns - map from condition -> index of patterns, for deduplication.

Throws:

IOException - Can be thrown while reading the rule

ParseException

affixData

char affixData(int affixIndex,
 int offset)

isCrossProduct

boolean isCrossProduct(int affix)

getAffixCondition

int getAffixCondition(int affix)

parseConversions

private ConvTable parseConversions(LineNumberReader reader,
 int num)
                            throws IOException,
ParseException

Throws:

IOException

ParseException

readConfig

private void readConfig(InputStream stream,
 Charset streamCharset)
                 throws IOException,
ParseException

Parses the encoding and flag format specified in the provided InputStream

Throws:

IOException

ParseException

maybeConsume

private static boolean maybeConsume(BufferedInputStream stream,
 byte[] bytes)
                             throws IOException

Consume the provided byte sequence in full, if present. Otherwise leave the input stream intact.

Returns:

true if the sequence matched and has been consumed.

Throws:

IOException

getDecoder

private CharsetDecoder getDecoder(String encoding)

Retrieves the CharsetDecoder for the given encoding. Note, This isn't perfect as I think ISCII-DEVANAGARI and MICROSOFT-CP1251 etc are allowed...

Parameters:

encoding - Encoding to retrieve the CharsetDecoder for

Returns:

CharSetDecoder for the given encoding

replacingDecoder

private static CharsetDecoder replacingDecoder(Charset charset)

getFlagParsingStrategy

static Dictionary.FlagParsingStrategy getFlagParsingStrategy(String flagLine,
 Charset charset)

Determines the appropriate Dictionary.FlagParsingStrategy based on the FLAG definition line taken from the affix file

Parameters:

flagLine - Line containing the flag information

Returns:

FlagParsingStrategy that handles parsing flags in the way specified in the FLAG definition

unescapeEntry

private String unescapeEntry(String entry)

shouldSkipEscapedChar

private static boolean shouldSkipEscapedChar(char ch)

morphBoundary

private static int morphBoundary(String line)

indexOfSpaceOrTab

static int indexOfSpaceOrTab(String text,
 int start)

mergeDictionaries

private void mergeDictionaries(List<InputStream> dictionaries,
 CharsetDecoder decoder,
 SortingStrategy.EntryAccumulator acc)
                        throws IOException

Throws:

IOException

writeNormalizedWordEntry

private void writeNormalizedWordEntry(StringBuilder reuse,
 String line,
 SortingStrategy.EntryAccumulator acc)
                               throws IOException

Throws:

IOException

addHiddenCapitalizedWord

private void addHiddenCapitalizedWord(StringBuilder reuse,
 SortingStrategy.EntryAccumulator acc,
 String word,
 String afterSep)
                               throws IOException

Throws:

IOException

toLowerCase

String toLowerCase(String word)

toTitleCase

String toTitleCase(String word)

readSortedDictionaries

private WordStorage readSortedDictionaries(FlagEnumerator flags,
 SortingStrategy.EntrySupplier sorted)
                                    throws IOException

Throws:

IOException

hashFactor

protected double hashFactor()

The factor determining the size of the internal hash table used for storing the entries. The table size is entry_count * hashFactor. The default factor is 1.0. If there are too many hash collisions, the factor can be increased, resulting in faster access, but more memory usage.

tolerateAffixRuleCountMismatches

protected boolean tolerateAffixRuleCountMismatches()

Whether incorrect PFX/SFX rule counts should be silently ignored. False by default: a ParseException will happen.

tolerateDuplicateConversionMappings

protected boolean tolerateDuplicateConversionMappings()

Whether duplicate ICONV/OCONV lines should be silently ignored. False by default: an IllegalStateException will happen.

allNonSuggestibleFlags

char[] allNonSuggestibleFlags()

readMorphFields

private List<String> readMorphFields(String word,
 String unparsed)

addMorphFields

private int addMorphFields(Map<String,Integer> indices,
 String morphFields)

addPhoneticRepEntries

private void addPhoneticRepEntries(String word,
 String ph)

isDotICaseChangeDisallowed

boolean isDotICaseChangeDisallowed(char[] word)

parseAlias

private void parseAlias(String line)

getAliasValue

private String getAliasValue(int id)

parseMorphAlias

private void parseMorphAlias(String line)

splitMorphData

private List<String> splitMorphData(String morphData)

hasFlag

boolean hasFlag(IntsRef forms,
 char flag)

isFlagAppendedByAffix

boolean isFlagAppendedByAffix(int affixId,
 char flag)

hasFlag

boolean hasFlag(int entryId,
 char flag)

mayNeedInputCleaning

boolean mayNeedInputCleaning()

needsInputCleaning

boolean needsInputCleaning(CharSequence input)

cleanInput

CharSequence cleanInput(CharSequence input,
 StringBuilder reuse)

toSortedCharArray

static char[] toSortedCharArray(CharHashSet set)

isSecondStagePrefix

boolean isSecondStagePrefix(char flag)

isSecondStageSuffix

boolean isSecondStageSuffix(char flag)

caseFold

char caseFold(char c)

folds single character (according to LANG if present)

getIgnoreCase

public boolean getIgnoreCase()

Returns true if this dictionary was constructed with the ignoreCase option

getDefaultTempDir

static Path getDefaultTempDir()
                       throws IOException

Returns the default temporary directory pointed to by java.io.tmpdir. If not accessible or not available, an IOException is thrown.

Throws:

IOException