Home | History | Annotate | Download | only in dictionary 
      1 /*
      2  * Copyright (C) 2009, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "LatinIME: dictionary.cpp"
     18 
     19 #include "suggest/core/dictionary/dictionary.h"
     20 
     21 #include <stdint.h>
     22 
     23 #include "defines.h"
     24 #include "suggest/core/dictionary/bigram_dictionary.h"
     25 #include "suggest/core/policy/dictionary_header_structure_policy.h"
     26 #include "suggest/core/policy/dictionary_structure_with_buffer_policy.h"
     27 #include "suggest/core/session/dic_traverse_session.h"
     28 #include "suggest/core/suggest.h"
     29 #include "suggest/core/suggest_options.h"
     30 #include "suggest/policyimpl/gesture/gesture_suggest_policy_factory.h"
     31 #include "suggest/policyimpl/typing/typing_suggest_policy_factory.h"
     32 #include "utils/log_utils.h"
     33 
     34 namespace latinime {
     35 
     36 const int Dictionary::HEADER_ATTRIBUTE_BUFFER_SIZE = 32;
     37 
     38 Dictionary::Dictionary(JNIEnv *env,
     39         DictionaryStructureWithBufferPolicy *const dictionaryStructureWithBufferPolicy)
     40         : mDictionaryStructureWithBufferPolicy(dictionaryStructureWithBufferPolicy),
     41           mBigramDictionary(new BigramDictionary(mDictionaryStructureWithBufferPolicy)),
     42           mGestureSuggest(new Suggest(GestureSuggestPolicyFactory::getGestureSuggestPolicy())),
     43           mTypingSuggest(new Suggest(TypingSuggestPolicyFactory::getTypingSuggestPolicy())) {
     44     logDictionaryInfo(env);
     45 }
     46 
     47 Dictionary::~Dictionary() {
     48     delete mBigramDictionary;
     49     delete mGestureSuggest;
     50     delete mTypingSuggest;
     51     delete mDictionaryStructureWithBufferPolicy;
     52 }
     53 
     54 int Dictionary::getSuggestions(ProximityInfo *proximityInfo, DicTraverseSession *traverseSession,
     55         int *xcoordinates, int *ycoordinates, int *times, int *pointerIds, int *inputCodePoints,
     56         int inputSize, int *prevWordCodePoints, int prevWordLength, int commitPoint,
     57         const SuggestOptions *const suggestOptions, int *outWords, int *frequencies,
     58         int *spaceIndices, int *outputTypes, int *outputAutoCommitFirstWordConfidence) const {
     59     int result = 0;
     60     if (suggestOptions->isGesture()) {
     61         DicTraverseSession::initSessionInstance(
     62                 traverseSession, this, prevWordCodePoints, prevWordLength, suggestOptions);
     63         result = mGestureSuggest->getSuggestions(proximityInfo, traverseSession, xcoordinates,
     64                 ycoordinates, times, pointerIds, inputCodePoints, inputSize, commitPoint, outWords,
     65                 frequencies, spaceIndices, outputTypes, outputAutoCommitFirstWordConfidence);
     66         if (DEBUG_DICT) {
     67             DUMP_RESULT(outWords, frequencies);
     68         }
     69         return result;
     70     } else {
     71         DicTraverseSession::initSessionInstance(
     72                 traverseSession, this, prevWordCodePoints, prevWordLength, suggestOptions);
     73         result = mTypingSuggest->getSuggestions(proximityInfo, traverseSession, xcoordinates,
     74                 ycoordinates, times, pointerIds, inputCodePoints, inputSize, commitPoint,
     75                 outWords, frequencies, spaceIndices, outputTypes,
     76                 outputAutoCommitFirstWordConfidence);
     77         if (DEBUG_DICT) {
     78             DUMP_RESULT(outWords, frequencies);
     79         }
     80         return result;
     81     }
     82 }
     83 
     84 int Dictionary::getBigrams(const int *word, int length, int *outWords, int *frequencies,
     85         int *outputTypes) const {
     86     if (length <= 0) return 0;
     87     return mBigramDictionary->getPredictions(word, length, outWords, frequencies, outputTypes);
     88 }
     89 
     90 int Dictionary::getProbability(const int *word, int length) const {
     91     int pos = getDictionaryStructurePolicy()->getTerminalNodePositionOfWord(word, length,
     92             false /* forceLowerCaseSearch */);
     93     if (NOT_A_DICT_POS == pos) {
     94         return NOT_A_PROBABILITY;
     95     }
     96     return getDictionaryStructurePolicy()->getUnigramProbabilityOfPtNode(pos);
     97 }
     98 
     99 int Dictionary::getBigramProbability(const int *word0, int length0, const int *word1,
    100         int length1) const {
    101     return mBigramDictionary->getBigramProbability(word0, length0, word1, length1);
    102 }
    103 
    104 void Dictionary::addUnigramWord(const int *const word, const int length, const int probability) {
    105     mDictionaryStructureWithBufferPolicy->addUnigramWord(word, length, probability);
    106 }
    107 
    108 void Dictionary::addBigramWords(const int *const word0, const int length0, const int *const word1,
    109         const int length1, const int probability) {
    110     mDictionaryStructureWithBufferPolicy->addBigramWords(word0, length0, word1, length1,
    111             probability);
    112 }
    113 
    114 void Dictionary::removeBigramWords(const int *const word0, const int length0,
    115         const int *const word1, const int length1) {
    116     mDictionaryStructureWithBufferPolicy->removeBigramWords(word0, length0, word1, length1);
    117 }
    118 
    119 void Dictionary::flush(const char *const filePath) {
    120     mDictionaryStructureWithBufferPolicy->flush(filePath);
    121 }
    122 
    123 void Dictionary::flushWithGC(const char *const filePath) {
    124     mDictionaryStructureWithBufferPolicy->flushWithGC(filePath);
    125 }
    126 
    127 bool Dictionary::needsToRunGC(const bool mindsBlockByGC) {
    128     return mDictionaryStructureWithBufferPolicy->needsToRunGC(mindsBlockByGC);
    129 }
    130 
    131 void Dictionary::getProperty(const char *const query, char *const outResult,
    132         const int maxResultLength) {
    133     return mDictionaryStructureWithBufferPolicy->getProperty(query, outResult, maxResultLength);
    134 }
    135 
    136 void Dictionary::logDictionaryInfo(JNIEnv *const env) const {
    137     int dictionaryIdCodePointBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
    138     int versionStringCodePointBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
    139     int dateStringCodePointBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
    140     const DictionaryHeaderStructurePolicy *const headerPolicy =
    141             getDictionaryStructurePolicy()->getHeaderStructurePolicy();
    142     headerPolicy->readHeaderValueOrQuestionMark("dictionary", dictionaryIdCodePointBuffer,
    143             HEADER_ATTRIBUTE_BUFFER_SIZE);
    144     headerPolicy->readHeaderValueOrQuestionMark("version", versionStringCodePointBuffer,
    145             HEADER_ATTRIBUTE_BUFFER_SIZE);
    146     headerPolicy->readHeaderValueOrQuestionMark("date", dateStringCodePointBuffer,
    147             HEADER_ATTRIBUTE_BUFFER_SIZE);
    148 
    149     char dictionaryIdCharBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
    150     char versionStringCharBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
    151     char dateStringCharBuffer[HEADER_ATTRIBUTE_BUFFER_SIZE];
    152     intArrayToCharArray(dictionaryIdCodePointBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE,
    153             dictionaryIdCharBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE);
    154     intArrayToCharArray(versionStringCodePointBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE,
    155             versionStringCharBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE);
    156     intArrayToCharArray(dateStringCodePointBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE,
    157             dateStringCharBuffer, HEADER_ATTRIBUTE_BUFFER_SIZE);
    158 
    159     LogUtils::logToJava(env,
    160             "Dictionary info: dictionary = %s ; version = %s ; date = %s",
    161             dictionaryIdCharBuffer, versionStringCharBuffer, dateStringCharBuffer);
    162 }
    163 
    164 } // namespace latinime
    165