org.apache.lucene/lucene-analyzers-kuromoji/8.7.0

https://lucene.apache.org/lucene-parent/lucene-analyzers-kuromoji: Lucene Kuromoji Japanese Morphological Analyzer (The Apache Software Foundation)

Apache License, Version 2.0

directory

Dependencies

directory

Declarations

org
- apache
  - lucene
    - analysis
      - ja
        
        GraphvizFormatter
        
        sb: StringBuilder
        
        BOS_LABEL: String
        
        EOS_LABEL: String
        
        FONT_NAME: String
        
        costs: ConnectionCosts
        
        bestPathMap: Map<String, String>
        
        GraphvizFormatter(ConnectionCosts): void
        
        finish(): String
        
        onBacktrace(JapaneseTokenizer, WrappedPositionArray, int, Position, int, char[], boolean): void
        
        setBestPathMap(WrappedPositionArray, int, Position, int): void
        
        formatNodes(JapaneseTokenizer, WrappedPositionArray, int, Position, char[]): String
        
        formatHeader(): String
        
        formatTrailer(): String
        
        getNodeID(int, int): String
        
        JapaneseAnalyzer
        
        mode: Mode
        
        stoptags: Set<String>
        
        userDict: UserDictionary
        
        JapaneseAnalyzer(): void
        
        JapaneseAnalyzer(UserDictionary, Mode, CharArraySet, Set<String>): void
        
        getDefaultStopSet(): CharArraySet
        
        getDefaultStopTags(): Set<String>
        
        DefaultSetHolder
        
        DEFAULT_STOP_SET: CharArraySet
        
        DEFAULT_STOP_TAGS: Set<String>
        
        static class initializer
        
        createComponents(String): TokenStreamComponents
        
        normalize(String, TokenStream): TokenStream
        
        JapaneseBaseFormFilter
        
        termAtt: CharTermAttribute
        
        basicFormAtt: BaseFormAttribute
        
        keywordAtt: KeywordAttribute
        
        JapaneseBaseFormFilter(TokenStream): void
        
        incrementToken(): boolean
        
        JapaneseBaseFormFilterFactory
        
        NAME: String
        
        JapaneseBaseFormFilterFactory(Map<String, String>): void
        
        create(TokenStream): TokenStream
        
        JapaneseIterationMarkCharFilter
        
        NORMALIZE_KANJI_DEFAULT: boolean
        
        NORMALIZE_KANA_DEFAULT: boolean
        
        KANJI_ITERATION_MARK: char
        
        HIRAGANA_ITERATION_MARK: char
        
        HIRAGANA_VOICED_ITERATION_MARK: char
        
        KATAKANA_ITERATION_MARK: char
        
        KATAKANA_VOICED_ITERATION_MARK: char
        
        FULL_STOP_PUNCTUATION: char
        
        h2d: char[]
        
        k2d: char[]
        
        buffer: RollingCharBuffer
        
        bufferPosition: int
        
        iterationMarksSpanSize: int
        
        iterationMarkSpanEndPosition: int
        
        normalizeKanji: boolean
        
        normalizeKana: boolean
        
        static class initializer
        
        JapaneseIterationMarkCharFilter(Reader): void
        
        JapaneseIterationMarkCharFilter(Reader, boolean, boolean): void
        
        read(char[], int, int): int
        
        read(): int
        
        normalizeIterationMark(char): char
        
        nextIterationMarkSpanSize(): int
        
        sourceCharacter(int, int): char
        
        normalize(char, char): char
        
        normalizedHiragana(char, char): char
        
        normalizedKatakana(char, char): char
        
        isIterationMark(char): boolean
        
        isHiraganaIterationMark(char): boolean
        
        isKatakanaIterationMark(char): boolean
        
        isKanjiIterationMark(char): boolean
        
        lookupHiraganaDakuten(char): char
        
        lookupKatakanaDakuten(char): char
        
        isHiraganaDakuten(char): boolean
        
        isKatakanaDakuten(char): boolean
        
        lookup(char, char[], char): char
        
        inside(char, char[], char): boolean
        
        correct(int): int
        
        JapaneseIterationMarkCharFilterFactory
        
        NAME: String
        
        NORMALIZE_KANJI_PARAM: String
        
        NORMALIZE_KANA_PARAM: String
        
        normalizeKanji: boolean
        
        normalizeKana: boolean
        
        JapaneseIterationMarkCharFilterFactory(Map<String, String>): void
        
        create(Reader): Reader
        
        normalize(Reader): Reader
        
        JapaneseKatakanaStemFilter
        
        DEFAULT_MINIMUM_LENGTH: int
        
        HIRAGANA_KATAKANA_PROLONGED_SOUND_MARK: char
        
        termAttr: CharTermAttribute
        
        keywordAttr: KeywordAttribute
        
        minimumKatakanaLength: int
        
        JapaneseKatakanaStemFilter(TokenStream, int): void
        
        JapaneseKatakanaStemFilter(TokenStream): void
        
        incrementToken(): boolean
        
        stem(char[], int): int
        
        isKatakana(char[], int): boolean
        
        JapaneseKatakanaStemFilterFactory
        
        NAME: String
        
        MINIMUM_LENGTH_PARAM: String
        
        minimumLength: int
        
        JapaneseKatakanaStemFilterFactory(Map<String, String>): void
        
        create(TokenStream): TokenStream
        
        JapaneseNumberFilter
        
        termAttr: CharTermAttribute
        
        offsetAttr: OffsetAttribute
        
        keywordAttr: KeywordAttribute
        
        posIncrAttr: PositionIncrementAttribute
        
        posLengthAttr: PositionLengthAttribute
        
        NO_NUMERAL: char
        
        numerals: char[]
        
        exponents: char[]
        
        state: State
        
        numeral: StringBuilder
        
        fallThroughTokens: int
        
        exhausted: boolean
        
        static class initializer
        
        JapaneseNumberFilter(TokenStream): void
        
        incrementToken(): boolean
        
        reset(): void
        
        normalizeNumber(String): String
        
        parseNumber(NumberBuffer): BigDecimal
        
        parseLargePair(NumberBuffer): BigDecimal
        
        parseMediumNumber(NumberBuffer): BigDecimal
        
        parseMediumPair(NumberBuffer): BigDecimal
        
        parseBasicNumber(NumberBuffer): BigDecimal
        
        parseLargeKanjiNumeral(NumberBuffer): BigDecimal
        
        parseMediumKanjiNumeral(NumberBuffer): BigDecimal
        
        isNumeral(String): boolean
        
        isNumeral(char): boolean
        
        isNumeralPunctuation(String): boolean
        
        isNumeralPunctuation(char): boolean
        
        isArabicNumeral(char): boolean
        
        isHalfWidthArabicNumeral(char): boolean
        
        isFullWidthArabicNumeral(char): boolean
        
        arabicNumeralValue(char): int
        
        isKanjiNumeral(char): boolean
        
        kanjiNumeralValue(char): int
        
        isDecimalPoint(char): boolean
        
        isThousandSeparator(char): boolean
        
        NumberBuffer
        
        position: int
        
        string: String
        
        NumberBuffer(String): void
        
        charAt(int): char
        
        length(): int
        
        advance(): void
        
        position(): int
        
        JapaneseNumberFilterFactory
        
        NAME: String
        
        JapaneseNumberFilterFactory(Map<String, String>): void
        
        create(TokenStream): TokenStream
        
        JapanesePartOfSpeechStopFilter
        
        stopTags: Set<String>
        
        posAtt: PartOfSpeechAttribute
        
        JapanesePartOfSpeechStopFilter(TokenStream, Set<String>): void
        
        accept(): boolean
        
        JapanesePartOfSpeechStopFilterFactory
        
        NAME: String
        
        stopTagFiles: String
        
        stopTags: Set<String>
        
        JapanesePartOfSpeechStopFilterFactory(Map<String, String>): void
        
        inform(ResourceLoader): void
        
        create(TokenStream): TokenStream
        
        JapaneseReadingFormFilter
        
        termAttr: CharTermAttribute
        
        readingAttr: ReadingAttribute
        
        buffer: StringBuilder
        
        useRomaji: boolean
        
        JapaneseReadingFormFilter(TokenStream, boolean): void
        
        JapaneseReadingFormFilter(TokenStream): void
        
        incrementToken(): boolean
        
        JapaneseReadingFormFilterFactory
        
        NAME: String
        
        ROMAJI_PARAM: String
        
        useRomaji: boolean
        
        JapaneseReadingFormFilterFactory(Map<String, String>): void
        
        create(TokenStream): TokenStream
        
        JapaneseTokenizer
        
        Mode
        
        NORMAL: Mode
        
        SEARCH: Mode
        
        EXTENDED: Mode
        
        DEFAULT_MODE: Mode
        
        Type
        
        KNOWN: Type
        
        UNKNOWN: Type
        
        USER: Type
        
        VERBOSE: boolean
        
        SEARCH_MODE_KANJI_LENGTH: int
        
        SEARCH_MODE_OTHER_LENGTH: int
        
        SEARCH_MODE_KANJI_PENALTY: int
        
        SEARCH_MODE_OTHER_PENALTY: int
        
        MAX_UNKNOWN_WORD_LENGTH: int
        
        MAX_BACKTRACE_GAP: int
        
        dictionaryMap: EnumMap<Type, Dictionary>
        
        fst: TokenInfoFST
        
        dictionary: TokenInfoDictionary
        
        unkDictionary: UnknownDictionary
        
        costs: ConnectionCosts
        
        userDictionary: UserDictionary
        
        characterDefinition: CharacterDefinition
        
        arc: Arc<Long>
        
        fstReader: BytesReader
        
        wordIdRef: IntsRef
        
        userFSTReader: BytesReader
        
        userFST: TokenInfoFST
        
        buffer: RollingCharBuffer
        
        positions: WrappedPositionArray
        
        discardPunctuation: boolean
        
        searchMode: boolean
        
        extendedMode: boolean
        
        outputCompounds: boolean
        
        outputNBest: boolean
        
        nBestCost: int
        
        end: boolean
        
        lastBackTracePos: int
        
        lastTokenPos: int
        
        pos: int
        
        pending: List<Token>
        
        termAtt: CharTermAttribute
        
        offsetAtt: OffsetAttribute
        
        posIncAtt: PositionIncrementAttribute
        
        posLengthAtt: PositionLengthAttribute
        
        basicFormAtt: BaseFormAttribute
        
        posAtt: PartOfSpeechAttribute
        
        readingAtt: ReadingAttribute
        
        inflectionAtt: InflectionAttribute
        
        JapaneseTokenizer(UserDictionary, boolean, Mode): void
        
        JapaneseTokenizer(UserDictionary, boolean, boolean, Mode): void
        
        JapaneseTokenizer(AttributeFactory, UserDictionary, boolean, Mode): void
        
        JapaneseTokenizer(AttributeFactory, UserDictionary, boolean, boolean, Mode): void
        
        JapaneseTokenizer(AttributeFactory, TokenInfoDictionary, UnknownDictionary, ConnectionCosts, UserDictionary, boolean, boolean, Mode): void
        
        dotOut: GraphvizFormatter
        
        setGraphvizFormatter(GraphvizFormatter): void
        
        close(): void
        
        reset(): void
        
        resetState(): void
        
        end(): void
        
        computeSecondBestThreshold(int, int): int
        
        computePenalty(int, int): int
        
        Position
        
        pos: int
        
        count: int
        
        costs: int[]
        
        lastRightID: int[]
        
        backPos: int[]
        
        backIndex: int[]
        
        backID: int[]
        
        backType: Type[]
        
        forwardCount: int
        
        forwardPos: int[]
        
        forwardID: int[]
        
        forwardIndex: int[]
        
        forwardType: Type[]
        
        grow(): void
        
        growForward(): void
        
        add(int, int, int, int, int, Type): void
        
        addForward(int, int, int, Type): void
        
        reset(): void
        
        add(Dictionary, Position, int, int, Type, boolean): void
        
        incrementToken(): boolean
        
        WrappedPositionArray
        
        positions: Position[]
        
        WrappedPositionArray(): void
        
        nextWrite: int
        
        nextPos: int
        
        count: int
        
        reset(): void
        
        get(int): Position
        
        getNextPos(): int
        
        inBounds(int): boolean
        
        getIndex(int): int
        
        freeBefore(int): void
        
        parse(): void
        
        pruneAndRescore(int, int, int): void
        
        Lattice
        
        nodeLeft: int[]
        
        fragment: char[]
        
        dictionaryMap: EnumMap<Type, Dictionary>
        
        useEOS: boolean
        
        rootCapacity: int
        
        rootSize: int
        
        rootBase: int
        
        lRoot: int[]
        
        rRoot: int[]
        
        capacity: int
        
        nodeCount: int
        
        nodeDicType: Type[]
        
        nodeWordID: int[]
        
        nodeMark: int[]
        
        nodeLeftID: int[]
        
        nodeRightID: int[]
        
        nodeWordCost: int[]
        
        nodeLeftCost: int[]
        
        nodeRightCost: int[]
        
        nodeLeftNode: int[]
        
        nodeRightNode: int[]
        
        nodeRight: int[]
        
        nodeLeftChain: int[]
        
        nodeRightChain: int[]
        
        setupRoot(int, int): void
        
        reserve(int): void
        
        setupNodePool(int): void
        
        addNode(Type, int, int, int): int
        
        positionCount(WrappedPositionArray, int, int): int
        
        setup(char[], EnumMap<Type, Dictionary>, WrappedPositionArray, int, int, boolean): void
        
        markUnreachable(): void
        
        connectionCost(ConnectionCosts, int, int): int
        
        calcLeftCost(ConnectionCosts): void
        
        calcRightCost(ConnectionCosts): void
        
        markSameSpanNode(int, int): void
        
        bestPathNodeList(): List<Integer>
        
        cost(int): int
        
        nBestNodeList(int): List<Integer>
        
        bestCost(): int
        
        probeDelta(int, int): int
        
        debugPrint(): void
        
        lattice: Lattice
        
        registerNode(int, char[]): void
        
        fixupPendingList(): void
        
        $1
        
        compare(Token, Token): int
        
        probeDelta(String, String): int
        
        calcNBestCost(String): int
        
        setNBestCost(int): void
        
        backtraceNBest(Position, boolean): void
        
        backtrace(Position, int): void
        
        getDict(Type): Dictionary
        
        isPunctuation(char): boolean
        
        JapaneseTokenizerFactory
        
        NAME: String
        
        MODE: String
        
        USER_DICT_PATH: String
        
        USER_DICT_ENCODING: String
        
        DISCARD_PUNCTUATION: String
        
        DISCARD_COMPOUND_TOKEN: String
        
        NBEST_COST: String
        
        NBEST_EXAMPLES: String
        
        userDictionary: UserDictionary
        
        mode: Mode
        
        discardPunctuation: boolean
        
        discardCompoundToken: boolean
        
        userDictionaryPath: String
        
        userDictionaryEncoding: String
        
        nbestExamples: String
        
        nbestCost: int
        
        JapaneseTokenizerFactory(Map<String, String>): void
        
        inform(ResourceLoader): void
        
        create(AttributeFactory): JapaneseTokenizer
        
        Token
        
        dictionary: Dictionary
        
        wordId: int
        
        surfaceForm: char[]
        
        offset: int
        
        length: int
        
        position: int
        
        positionLength: int
        
        type: Type
        
        Token(int, char[], int, int, Type, int, Dictionary): void
        
        toString(): String
        
        getSurfaceForm(): char[]
        
        getOffset(): int
        
        getLength(): int
        
        getSurfaceFormString(): String
        
        getReading(): String
        
        getPronunciation(): String
        
        getPartOfSpeech(): String
        
        getInflectionType(): String
        
        getInflectionForm(): String
        
        getBaseForm(): String
        
        getType(): Type
        
        isKnown(): boolean
        
        isUnknown(): boolean
        
        isUser(): boolean
        
        getPosition(): int
        
        setPositionLength(int): void
        
        getPositionLength(): int
        
        dict
        
        BinaryDictionary
        
        ResourceScheme
        
        CLASSPATH: ResourceScheme
        
        FILE: ResourceScheme
        
        DICT_FILENAME_SUFFIX: String
        
        TARGETMAP_FILENAME_SUFFIX: String
        
        POSDICT_FILENAME_SUFFIX: String
        
        DICT_HEADER: String
        
        TARGETMAP_HEADER: String
        
        POSDICT_HEADER: String
        
        VERSION: int
        
        resourceScheme: ResourceScheme
        
        resourcePath: String
        
        buffer: ByteBuffer
        
        targetMapOffsets: int[]
        
        targetMap: int[]
        
        posDict: String[]
        
        inflTypeDict: String[]
        
        inflFormDict: String[]
        
        BinaryDictionary(): void
        
        BinaryDictionary(ResourceScheme, String): void
        
        getResource(String): InputStream
        
        getResource(ResourceScheme, String): InputStream
        
        getClassResource(Class<Object>, String): InputStream
        
        getClassResource(String): InputStream
        
        lookupWordIds(int, IntsRef): void
        
        getLeftId(int): int
        
        getRightId(int): int
        
        getWordCost(int): int
        
        getBaseForm(int, char[], int, int): String
        
        getReading(int, char[], int, int): String
        
        getPartOfSpeech(int): String
        
        getPronunciation(int, char[], int, int): String
        
        getInflectionType(int): String
        
        getInflectionForm(int): String
        
        baseFormOffset(int): int
        
        readingOffset(int): int
        
        pronunciationOffset(int): int
        
        hasBaseFormData(int): boolean
        
        hasReadingData(int): boolean
        
        hasPronunciationData(int): boolean
        
        readString(int, int, boolean): String
        
        HAS_BASEFORM: int
        
        HAS_READING: int
        
        HAS_PRONUNCIATION: int
        
        CharacterDefinition
        
        SYMBOL: byte
        
        NUMERIC: byte
        
        FILENAME_SUFFIX: String
        
        HEADER: String
        
        VERSION: int
        
        CLASS_COUNT: int
        
        CharacterClass
        
        NGRAM: CharacterClass
        
        DEFAULT: CharacterClass
        
        SPACE: CharacterClass
        
        SYMBOL: CharacterClass
        
        NUMERIC: CharacterClass
        
        ALPHA: CharacterClass
        
        CYRILLIC: CharacterClass
        
        GREEK: CharacterClass
        
        HIRAGANA: CharacterClass
        
        KATAKANA: CharacterClass
        
        KANJI: CharacterClass
        
        KANJINUMERIC: CharacterClass
        
        characterCategoryMap: byte[]
        
        invokeMap: boolean[]
        
        groupMap: boolean[]
        
        NGRAM: byte
        
        DEFAULT: byte
        
        SPACE: byte
        
        ALPHA: byte
        
        CYRILLIC: byte
        
        GREEK: byte
        
        HIRAGANA: byte
        
        KATAKANA: byte
        
        KANJI: byte
        
        KANJINUMERIC: byte
        
        CharacterDefinition(): void
        
        getCharacterClass(char): byte
        
        isInvoke(char): boolean
        
        isGroup(char): boolean
        
        isKanji(char): boolean
        
        lookupCharacterClass(String): byte
        
        getInstance(): CharacterDefinition
        
        SingletonHolder
        
        INSTANCE: CharacterDefinition
        
        static class initializer
        
        ConnectionCosts
        
        FILENAME_SUFFIX: String
        
        HEADER: String
        
        VERSION: int
        
        costs: short[][]
        
        ConnectionCosts(ResourceScheme, String): void
        
        ConnectionCosts(): void
        
        get(int, int): int
        
        getInstance(): ConnectionCosts
        
        SingletonHolder
        
        INSTANCE: ConnectionCosts
        
        static class initializer
        
        Dictionary
        
        INTERNAL_SEPARATOR: String
        
        getLeftId(int): int
        
        getRightId(int): int
        
        getWordCost(int): int
        
        getPartOfSpeech(int): String
        
        getReading(int, char[], int, int): String
        
        getBaseForm(int, char[], int, int): String
        
        getPronunciation(int, char[], int, int): String
        
        getInflectionType(int): String
        
        getInflectionForm(int): String
        
        TokenInfoDictionary
        
        FST_FILENAME_SUFFIX: String
        
        fst: TokenInfoFST
        
        TokenInfoDictionary(ResourceScheme, String): void
        
        TokenInfoDictionary(): void
        
        getFST(): TokenInfoFST
        
        getInstance(): TokenInfoDictionary
        
        SingletonHolder
        
        INSTANCE: TokenInfoDictionary
        
        static class initializer
        
        TokenInfoFST
        
        fst: FST<Long>
        
        cacheCeiling: int
        
        rootCache: Arc[]
        
        NO_OUTPUT: Long
        
        TokenInfoFST(FST<Long>, boolean): void
        
        cacheRootArcs(): Arc[]
        
        findTargetArc(int, Arc<Long>, Arc<Long>, boolean, BytesReader): Arc<Long>
        
        getFirstArc(Arc<Long>): Arc<Long>
        
        getBytesReader(): BytesReader
        
        getInternalFST(): FST<Long>
        
        UnknownDictionary
        
        characterDefinition: CharacterDefinition
        
        UnknownDictionary(ResourceScheme, String): void
        
        UnknownDictionary(): void
        
        lookup(char[], int, int): int
        
        getCharacterDefinition(): CharacterDefinition
        
        getReading(int, char[], int, int): String
        
        getInflectionType(int): String
        
        getInflectionForm(int): String
        
        getInstance(): UnknownDictionary
        
        SingletonHolder
        
        INSTANCE: UnknownDictionary
        
        static class initializer
        
        UserDictionary
        
        fst: TokenInfoFST
        
        segmentations: int[][]
        
        data: String[]
        
        CUSTOM_DICTIONARY_WORD_ID_OFFSET: int
        
        WORD_COST: int
        
        LEFT_ID: int
        
        RIGHT_ID: int
        
        open(Reader): UserDictionary
        
        UserDictionary(List<String[]>): void
        
        $1
        
        compare(String[], String[]): int
        
        lookup(char[], int, int): int[][]
        
        getFST(): TokenInfoFST
        
        EMPTY_RESULT: int[][]
        
        toIndexArray(Map<Integer, int[]>): int[][]
        
        lookupSegmentation(int): int[]
        
        getLeftId(int): int
        
        getRightId(int): int
        
        getWordCost(int): int
        
        getReading(int, char[], int, int): String
        
        getPartOfSpeech(int): String
        
        getBaseForm(int, char[], int, int): String
        
        getPronunciation(int, char[], int, int): String
        
        getInflectionType(int): String
        
        getInflectionForm(int): String
        
        getAllFeaturesArray(int): String[]
        
        getFeature(int, int[]): String
        
        tokenattributes
        
        BaseFormAttribute
        
        getBaseForm(): String
        
        setToken(Token): void
        
        BaseFormAttributeImpl
        
        token: Token
        
        getBaseForm(): String
        
        setToken(Token): void
        
        clear(): void
        
        copyTo(AttributeImpl): void
        
        reflectWith(AttributeReflector): void
        
        InflectionAttribute
        
        getInflectionType(): String
        
        getInflectionForm(): String
        
        setToken(Token): void
        
        InflectionAttributeImpl
        
        token: Token
        
        getInflectionType(): String
        
        getInflectionForm(): String
        
        setToken(Token): void
        
        clear(): void
        
        copyTo(AttributeImpl): void
        
        reflectWith(AttributeReflector): void
        
        PartOfSpeechAttribute
        
        getPartOfSpeech(): String
        
        setToken(Token): void
        
        PartOfSpeechAttributeImpl
        
        token: Token
        
        getPartOfSpeech(): String
        
        setToken(Token): void
        
        clear(): void
        
        copyTo(AttributeImpl): void
        
        reflectWith(AttributeReflector): void
        
        ReadingAttribute
        
        getReading(): String
        
        getPronunciation(): String
        
        setToken(Token): void
        
        ReadingAttributeImpl
        
        token: Token
        
        getReading(): String
        
        getPronunciation(): String
        
        setToken(Token): void
        
        clear(): void
        
        copyTo(AttributeImpl): void
        
        reflectWith(AttributeReflector): void
        
        util
        
        BinaryDictionaryWriter
        
        ID_LIMIT: int
        
        implClazz: Class<BinaryDictionary>
        
        buffer: ByteBuffer
        
        targetMapEndOffset: int
        
        lastWordId: int
        
        lastSourceId: int
        
        targetMap: int[]
        
        targetMapOffsets: int[]
        
        posDict: ArrayList<String>
        
        BinaryDictionaryWriter(Class<BinaryDictionary>, int): void
        
        put(String[]): int
        
        isKatakana(String): boolean
        
        writeKatakana(String): void
        
        toKatakana(String): String
        
        sharedPrefix(String, String): int
        
        addMapping(int, int): void
        
        getBaseFileName(): String
        
        write(Path): void
        
        writeTargetMap(Path): void
        
        writePosDict(Path): void
        
        writeDictionary(Path): void
        
        CSVUtil
        
        QUOTE: char
        
        COMMA: char
        
        QUOTE_REPLACE_PATTERN: Pattern
        
        ESCAPED_QUOTE: String
        
        CSVUtil(): void
        
        parse(String): String[]
        
        unQuoteUnEscape(String): String
        
        quoteEscape(String): String
        
        CharacterDefinitionWriter
        
        characterCategoryMap: byte[]
        
        invokeMap: boolean[]
        
        groupMap: boolean[]
        
        CharacterDefinitionWriter(): void
        
        putCharacterCategory(int, String): void
        
        putInvokeDefinition(String, int, int, int): void
        
        write(Path): void
        
        ConnectionCostsBuilder
        
        ConnectionCostsBuilder(): void
        
        build(Path): ConnectionCostsWriter
        
        ConnectionCostsWriter
        
        costs: short[][]
        
        forwardSize: int
        
        backwardSize: int
        
        ConnectionCostsWriter(int, int): void
        
        add(int, int, int): void
        
        write(Path): void
        
        DictionaryBuilder
        
        DictionaryFormat
        
        IPADIC: DictionaryFormat
        
        UNIDIC: DictionaryFormat
        
        DictionaryBuilder(): void
        
        build(DictionaryFormat, Path, Path, String, boolean): void
        
        main(String[]): void
        
        ToStringUtil
        
        posTranslations: HashMap<String, String>
        
        static class initializer
        
        getPOSTranslation(String): String
        
        inflTypeTranslations: HashMap<String, String>
        
        static class initializer
        
        getInflectionTypeTranslation(String): String
        
        inflFormTranslations: HashMap<String, String>
        
        static class initializer
        
        getInflectedFormTranslation(String): String
        
        getRomanization(String): String
        
        getRomanization(Appendable, CharSequence): void
        
        TokenInfoDictionaryBuilder
        
        encoding: String
        
        normalForm: Form
        
        format: DictionaryFormat
        
        offset: int
        
        TokenInfoDictionaryBuilder(DictionaryFormat, String, boolean): void
        
        build(Path): TokenInfoDictionaryWriter
        
        Lambda implementing Predicate<Path>
        
        buildDictionary(List<Path>): TokenInfoDictionaryWriter
        
        Lambda implementing Function<String[], String>
        
        formatEntry(String[]): String[]
        
        TokenInfoDictionaryWriter
        
        fst: FST<Long>
        
        TokenInfoDictionaryWriter(int): void
        
        setFST(FST<Long>): void
        
        write(Path): void
        
        writeFST(Path): void
        
        UnknownDictionaryBuilder
        
        NGRAM_DICTIONARY_ENTRY: String
        
        encoding: String
        
        UnknownDictionaryBuilder(String): void
        
        build(Path): UnknownDictionaryWriter
        
        readDictionaryFile(Path): UnknownDictionaryWriter
        
        readDictionaryFile(Path, String): UnknownDictionaryWriter
        
        Lambda implementing ToIntFunction<String[]>
        
        readCharacterDefinition(Path, UnknownDictionaryWriter): void
        
        UnknownDictionaryWriter
        
        characterDefinition: CharacterDefinitionWriter
        
        UnknownDictionaryWriter(int): void
        
        put(String[]): int
        
        putCharacterCategory(int, String): void
        
        putInvokeDefinition(String, int, int, int): void
        
        write(Path): void

directory

Java files

org/apache/lucene/analysis/ja/

directory

Class files

org/apache/lucene/analysis/ja/