Detach bigram functionarities from unigram_dictionary

Change-Id: Ie35164a5f293e5370885a1ba13d6ed7caf6000ec

native/src/bigram_dictionary.cpp

@@ -15,19 +15,240 @@
 ** limitations under the License.
 */
 
+#include <string.h>
+
 #define LOG_TAG "LatinIME: bigram_dictionary.cpp"
 
 #include "bigram_dictionary.h"
+#include "dictionary.h"
 
 namespace latinime {
 
-BigramDictionary::BigramDictionary(void *dict, int typedLetterMultiplier, int fullWordMultiplier,
-        int maxWordLength, int maxWords, int maxAlternatives, Dictionary *parentDictionary)
-{
+BigramDictionary::BigramDictionary(const unsigned char *dict, int maxWordLength,
+        int maxAlternatives, const bool isLatestDictVersion, const bool hasBigram,
+        Dictionary *parentDictionary)
+    : DICT(dict), MAX_WORD_LENGTH(maxWordLength),
+    MAX_ALTERNATIVES(maxAlternatives), IS_LATEST_DICT_VERSION(isLatestDictVersion),
+    HAS_BIGRAM(hasBigram), mParentDictionary(parentDictionary) {
+    LOGI("BigramDictionary - constructor");
+    LOGI("Has Bigram : %d \n", hasBigram);
+}
+
+BigramDictionary::~BigramDictionary() {
+}
+
+bool BigramDictionary::addWordBigram(unsigned short *word, int length, int frequency) {
+    word[length] = 0;
+    if (DEBUG_DICT) {
+        char s[length + 1];
+        for (int i = 0; i <= length; i++) s[i] = word[i];
+        LOGI("Bigram: Found word = %s, freq = %d : \n", s, frequency);
+    }
+
+    // Find the right insertion point
+    int insertAt = 0;
+    while (insertAt < mMaxBigrams) {
+        if (frequency > mBigramFreq[insertAt] || (mBigramFreq[insertAt] == frequency
+                && length < Dictionary::wideStrLen(mBigramChars + insertAt * MAX_WORD_LENGTH))) {
+            break;
+        }
+        insertAt++;
+    }
+    LOGI("Bigram: InsertAt -> %d maxBigrams: %d\n", insertAt, mMaxBigrams);
+    if (insertAt < mMaxBigrams) {
+        memmove((char*) mBigramFreq + (insertAt + 1) * sizeof(mBigramFreq[0]),
+               (char*) mBigramFreq + insertAt * sizeof(mBigramFreq[0]),
+               (mMaxBigrams - insertAt - 1) * sizeof(mBigramFreq[0]));
+        mBigramFreq[insertAt] = frequency;
+        memmove((char*) mBigramChars + (insertAt + 1) * MAX_WORD_LENGTH * sizeof(short),
+               (char*) mBigramChars + (insertAt    ) * MAX_WORD_LENGTH * sizeof(short),
+               (mMaxBigrams - insertAt - 1) * sizeof(short) * MAX_WORD_LENGTH);
+        unsigned short *dest = mBigramChars + (insertAt    ) * MAX_WORD_LENGTH;
+        while (length--) {
+            *dest++ = *word++;
+        }
+        *dest = 0; // NULL terminate
+        if (DEBUG_DICT) LOGI("Bigram: Added word at %d\n", insertAt);
+        return true;
+    }
+    return false;
+}
+
+int BigramDictionary::getBigramAddress(int *pos, bool advance) {
+    int address = 0;
+
+    address += (DICT[*pos] & 0x3F) << 16;
+    address += (DICT[*pos + 1] & 0xFF) << 8;
+    address += (DICT[*pos + 2] & 0xFF);
+
+    if (advance) {
+        *pos += 3;
+    }
+
+    return address;
+}
+
+int BigramDictionary::getBigramFreq(int *pos) {
+    int freq = DICT[(*pos)++] & FLAG_BIGRAM_FREQ;
+
+    return freq;
 }
 
-BigramDictionary::~BigramDictionary()
-{
+
+int BigramDictionary::getBigrams(unsigned short *prevWord, int prevWordLength, int *codes,
+        int codesSize, unsigned short *bigramChars, int *bigramFreq, int maxWordLength,
+        int maxBigrams, int maxAlternatives) {
+    mBigramFreq = bigramFreq;
+    mBigramChars = bigramChars;
+    mInputCodes = codes;
+    mInputLength = codesSize;
+    mMaxBigrams = maxBigrams;
+
+    if (HAS_BIGRAM && IS_LATEST_DICT_VERSION) {
+        int pos = mParentDictionary->isValidWordRec(
+                DICTIONARY_HEADER_SIZE, prevWord, 0, prevWordLength);
+        LOGI("Pos -> %d\n", pos);
+        if (pos < 0) {
+            return 0;
+        }
+
+        int bigramCount = 0;
+        int bigramExist = (DICT[pos] & FLAG_BIGRAM_READ);
+        if (bigramExist > 0) {
+            int nextBigramExist = 1;
+            while (nextBigramExist > 0 && bigramCount < maxBigrams) {
+                int bigramAddress = getBigramAddress(&pos, true);
+                int frequency = (FLAG_BIGRAM_FREQ & DICT[pos]);
+                // search for all bigrams and store them
+                searchForTerminalNode(bigramAddress, frequency);
+                nextBigramExist = (DICT[pos++] & FLAG_BIGRAM_CONTINUED);
+                bigramCount++;
+            }
+        }
+
+        return bigramCount;
+    }
+    return 0;
+}
+
+void BigramDictionary::searchForTerminalNode(int addressLookingFor, int frequency) {
+    // track word with such address and store it in an array
+    unsigned short word[MAX_WORD_LENGTH];
+
+    int pos;
+    int followDownBranchAddress = DICTIONARY_HEADER_SIZE;
+    bool found = false;
+    char followingChar = ' ';
+    int depth = -1;
+
+    while(!found) {
+        bool followDownAddressSearchStop = false;
+        bool firstAddress = true;
+        bool haveToSearchAll = true;
+
+        if (depth >= 0) {
+            word[depth] = (unsigned short) followingChar;
+        }
+        pos = followDownBranchAddress; // pos start at count
+        int count = DICT[pos] & 0xFF;
+        LOGI("count - %d\n",count);
+        pos++;
+        for (int i = 0; i < count; i++) {
+            // pos at data
+            pos++;
+            // pos now at flag
+            if (!getFirstBitOfByte(&pos)) { // non-terminal
+                if (!followDownAddressSearchStop) {
+                    int addr = getBigramAddress(&pos, false);
+                    if (addr > addressLookingFor) {
+                        followDownAddressSearchStop = true;
+                        if (firstAddress) {
+                            firstAddress = false;
+                            haveToSearchAll = true;
+                        } else if (!haveToSearchAll) {
+                            break;
+                        }
+                    } else {
+                        followDownBranchAddress = addr;
+                        followingChar = (char)(0xFF & DICT[pos-1]);
+                        if (firstAddress) {
+                            firstAddress = false;
+                            haveToSearchAll = false;
+                        }
+                    }
+                }
+                pos += 3;
+            } else if (getFirstBitOfByte(&pos)) { // terminal
+                if (addressLookingFor == (pos-1)) { // found !!
+                    depth++;
+                    word[depth] = (0xFF & DICT[pos-1]);
+                    found = true;
+                    break;
+                }
+                if (getSecondBitOfByte(&pos)) { // address + freq (4 byte)
+                    if (!followDownAddressSearchStop) {
+                        int addr = getBigramAddress(&pos, false);
+                        if (addr > addressLookingFor) {
+                            followDownAddressSearchStop = true;
+                            if (firstAddress) {
+                                firstAddress = false;
+                                haveToSearchAll = true;
+                            } else if (!haveToSearchAll) {
+                                break;
+                            }
+                        } else {
+                            followDownBranchAddress = addr;
+                            followingChar = (char)(0xFF & DICT[pos-1]);
+                            if (firstAddress) {
+                                firstAddress = false;
+                                haveToSearchAll = true;
+                            }
+                        }
+                    }
+                    pos += 4;
+                } else { // freq only (2 byte)
+                    pos += 2;
+                }
+
+                // skipping bigram
+                int bigramExist = (DICT[pos] & FLAG_BIGRAM_READ);
+                if (bigramExist > 0) {
+                    int nextBigramExist = 1;
+                    while (nextBigramExist > 0) {
+                        pos += 3;
+                        nextBigramExist = (DICT[pos++] & FLAG_BIGRAM_CONTINUED);
+                    }
+                } else {
+                    pos++;
+                }
+            }
+        }
+        depth++;
+        if (followDownBranchAddress == 0) {
+            LOGI("ERROR!!! Cannot find bigram!!");
+            break;
+        }
+    }
+    if (checkFirstCharacter(word)) {
+        addWordBigram(word, depth, frequency);
+    }
 }
+
+bool BigramDictionary::checkFirstCharacter(unsigned short *word) {
+    // Checks whether this word starts with same character or neighboring characters of
+    // what user typed.
+
+    int *inputCodes = mInputCodes;
+    int maxAlt = MAX_ALTERNATIVES;
+    while (maxAlt > 0) {
+        if ((unsigned int) *inputCodes == (unsigned int) *word) {
+            return true;
+        }
+        inputCodes++;
+        maxAlt--;
+    }
+    return false;
+}
+
 // TODO: Move functions related to bigram to here
 } // namespace latinime

native/src/bigram_dictionary.h

@@ -22,10 +22,33 @@ namespace latinime {
 class Dictionary;
 class BigramDictionary {
 public:
-    BigramDictionary(void *dict, int typedLetterMultipler, int fullWordMultiplier, int maxWordLength,
-            int maxWords, int maxAlternatives, Dictionary *parentDictionary);
+    BigramDictionary(const unsigned char *dict, int maxWordLength, int maxAlternatives,
+            const bool isLatestDictVersion, const bool hasBigram, Dictionary *parentDictionary);
+    int getBigrams(unsigned short *word, int length, int *codes, int codesSize,
+            unsigned short *outWords, int *frequencies, int maxWordLength, int maxBigrams,
+            int maxAlternatives);
     ~BigramDictionary();
 private:
+    bool addWordBigram(unsigned short *word, int length, int frequency);
+    int getBigramAddress(int *pos, bool advance);
+    int getBigramFreq(int *pos);
+    void searchForTerminalNode(int addressLookingFor, int frequency);
+    bool getFirstBitOfByte(int *pos) { return (DICT[*pos] & 0x80) > 0; }
+    bool getSecondBitOfByte(int *pos) { return (DICT[*pos] & 0x40) > 0; }
+    bool checkFirstCharacter(unsigned short *word);
+
+    const unsigned char *DICT;
+    const int MAX_WORD_LENGTH;
+    const int MAX_ALTERNATIVES;
+    const bool IS_LATEST_DICT_VERSION;
+    const bool HAS_BIGRAM;
+
+    Dictionary *mParentDictionary;
+    int *mBigramFreq;
+    int mMaxBigrams;
+    unsigned short *mBigramChars;
+    int *mInputCodes;
+    int mInputLength;
 };
 // ----------------------------------------------------------------------------
 }; // namespace latinime

native/src/dictionary.cpp

@@ -31,10 +31,9 @@ Dictionary::Dictionary(void *dict, int typedLetterMultiplier, int fullWordMultip
 {
     LOGI("IN NATIVE SUGGEST Version: %d \n", (DICT[0] & 0xFF));
     mUnigramDictionary = new UnigramDictionary(DICT, typedLetterMultiplier, fullWordMultiplier,
-            maxWordLength, maxWords, maxAlternatives, IS_LATEST_DICT_VERSION,
-            hasBigram(), this);
-    mBigramDictionary = new BigramDictionary(dict, typedLetterMultiplier, fullWordMultiplier,
-            maxWordLength, maxWords, maxAlternatives, this);
+            maxWordLength, maxWords, maxAlternatives, IS_LATEST_DICT_VERSION);
+    mBigramDictionary = new BigramDictionary(DICT, maxWordLength, maxAlternatives,
+            IS_LATEST_DICT_VERSION, hasBigram(), this);
 }
 
 Dictionary::~Dictionary()

native/src/dictionary.h

@@ -37,7 +37,7 @@ public:
     int getBigrams(unsigned short *word, int length, int *codes, int codesSize,
             unsigned short *outWords, int *frequencies, int maxWordLength, int maxBigrams,
             int maxAlternatives) {
-        return mUnigramDictionary->getBigrams(word, length, codes, codesSize, outWords, frequencies,
+        return mBigramDictionary->getBigrams(word, length, codes, codesSize, outWords, frequencies,
                 maxWordLength, maxBigrams, maxAlternatives);
     }
     bool isValidWord(unsigned short *word, int length);
@@ -53,6 +53,7 @@ public:
     static bool getTerminal(const unsigned char *dict, int *pos);
     static int getAddress(const unsigned char *dict, int *pos);
     static int getFreq(const unsigned char *dict, const bool isLatestDictVersion, int *pos);
+    static int wideStrLen(unsigned short *str);
 
 private:
     bool hasBigram();
@@ -117,5 +118,14 @@ inline int Dictionary::getFreq(const unsigned char *dict,
     return freq;
 }
 
+
+inline int Dictionary::wideStrLen(unsigned short *str) {
+    if (!str) return 0;
+    unsigned short *end = str;
+    while (*end)
+        end++;
+    return end - str;
+}
+
 }; // namespace latinime
 #endif // LATINIME_DICTIONARY_H

native/src/unigram_dictionary.cpp

@@ -31,23 +31,17 @@ namespace latinime {
 
 UnigramDictionary::UnigramDictionary(const unsigned char *dict, int typedLetterMultiplier,
         int fullWordMultiplier, int maxWordLength, int maxWords, int maxAlternatives,
-        const bool isLatestDictVersion, const bool hasBigram, Dictionary *parentDictionary)
+        const bool isLatestDictVersion)
     : DICT(dict), MAX_WORD_LENGTH(maxWordLength),MAX_WORDS(maxWords),
     MAX_ALTERNATIVES(maxAlternatives), IS_LATEST_DICT_VERSION(isLatestDictVersion),
-    HAS_BIGRAM(hasBigram), mParentDictionary(parentDictionary)
-{
+    TYPED_LETTER_MULTIPLIER(typedLetterMultiplier), FULL_WORD_MULTIPLIER(fullWordMultiplier) {
     LOGI("UnigramDictionary - constructor");
-    LOGI("Has Bigram : %d \n", hasBigram);
-    mTypedLetterMultiplier = typedLetterMultiplier;
-    mFullWordMultiplier = fullWordMultiplier;
 }
 
-UnigramDictionary::~UnigramDictionary()
-{
-}
+UnigramDictionary::~UnigramDictionary() {}
 
-int UnigramDictionary::getSuggestions(int *codes, int codesSize, unsigned short *outWords, int *frequencies,
-        int *nextLetters, int nextLettersSize)
+int UnigramDictionary::getSuggestions(int *codes, int codesSize, unsigned short *outWords,
+        int *frequencies, int *nextLetters, int nextLettersSize)
 {
 
     initSuggestions(codes, codesSize, outWords, frequencies);
@@ -114,16 +108,6 @@ void UnigramDictionary::registerNextLetter(unsigned short c, int *nextLetters, i
     }
 }
 
-int
-UnigramDictionary::wideStrLen(unsigned short *str)
-{
-    if (!str) return 0;
-    unsigned short *end = str;
-    while (*end)
-        end++;
-    return end - str;
-}
-
 bool
 UnigramDictionary::addWord(unsigned short *word, int length, int frequency)
 {
@@ -139,7 +123,7 @@ UnigramDictionary::addWord(unsigned short *word, int length, int frequency)
     while (insertAt < MAX_WORDS) {
         if (frequency > mFrequencies[insertAt]
                  || (mFrequencies[insertAt] == frequency
-                     && length < wideStrLen(mOutputChars + insertAt * MAX_WORD_LENGTH))) {
+                     && length < Dictionary::wideStrLen(mOutputChars + insertAt * MAX_WORD_LENGTH))) {
             break;
         }
         insertAt++;
@@ -163,46 +147,6 @@ UnigramDictionary::addWord(unsigned short *word, int length, int frequency)
     return false;
 }
 
-bool
-UnigramDictionary::addWordBigram(unsigned short *word, int length, int frequency)
-{
-    word[length] = 0;
-    if (DEBUG_DICT) {
-        char s[length + 1];
-        for (int i = 0; i <= length; i++) s[i] = word[i];
-        LOGI("Bigram: Found word = %s, freq = %d : \n", s, frequency);
-    }
-
-    // Find the right insertion point
-    int insertAt = 0;
-    while (insertAt < mMaxBigrams) {
-        if (frequency > mBigramFreq[insertAt]
-                 || (mBigramFreq[insertAt] == frequency
-                     && length < wideStrLen(mBigramChars + insertAt * MAX_WORD_LENGTH))) {
-            break;
-        }
-        insertAt++;
-    }
-    LOGI("Bigram: InsertAt -> %d maxBigrams: %d\n", insertAt, mMaxBigrams);
-    if (insertAt < mMaxBigrams) {
-        memmove((char*) mBigramFreq + (insertAt + 1) * sizeof(mBigramFreq[0]),
-               (char*) mBigramFreq + insertAt * sizeof(mBigramFreq[0]),
-               (mMaxBigrams - insertAt - 1) * sizeof(mBigramFreq[0]));
-        mBigramFreq[insertAt] = frequency;
-        memmove((char*) mBigramChars + (insertAt + 1) * MAX_WORD_LENGTH * sizeof(short),
-               (char*) mBigramChars + (insertAt    ) * MAX_WORD_LENGTH * sizeof(short),
-               (mMaxBigrams - insertAt - 1) * sizeof(short) * MAX_WORD_LENGTH);
-        unsigned short *dest = mBigramChars + (insertAt    ) * MAX_WORD_LENGTH;
-        while (length--) {
-            *dest++ = *word++;
-        }
-        *dest = 0; // NULL terminate
-        if (DEBUG_DICT) LOGI("Bigram: Added word at %d\n", insertAt);
-        return true;
-    }
-    return false;
-}
-
 unsigned short
 UnigramDictionary::toLowerCase(unsigned short c) {
     if (c < sizeof(BASE_CHARS) / sizeof(BASE_CHARS[0])) {
@@ -236,8 +180,8 @@ UnigramDictionary::sameAsTyped(unsigned short *word, int length)
 static char QUOTE = '\'';
 
 void
-UnigramDictionary::getWordsRec(int pos, int depth, int maxDepth, bool completion, int snr, int inputIndex,
-                        int diffs, int skipPos, int *nextLetters, int nextLettersSize)
+UnigramDictionary::getWordsRec(int pos, int depth, int maxDepth, bool completion, int snr,
+        int inputIndex, int diffs, int skipPos, int *nextLetters, int nextLettersSize)
 {
     // Optimization: Prune out words that are too long compared to how much was typed.
     if (depth > maxDepth) {
@@ -290,14 +234,14 @@ UnigramDictionary::getWordsRec(int pos, int depth, int maxDepth, bool completion
             int j = 0;
             while (currentChars[j] > 0) {
                 if (currentChars[j] == lowerC || currentChars[j] == c) {
-                    int addedWeight = j == 0 ? mTypedLetterMultiplier : 1;
+                    int addedWeight = j == 0 ? TYPED_LETTER_MULTIPLIER : 1;
                     mWord[depth] = c;
                     if (mInputLength == inputIndex + 1) {
                         if (terminal) {
                             if (//INCLUDE_TYPED_WORD_IF_VALID ||
                                 !sameAsTyped(mWord, depth + 1)) {
                                 int finalFreq = freq * snr * addedWeight;
-                                if (skipPos < 0) finalFreq *= mFullWordMultiplier;
+                                if (skipPos < 0) finalFreq *= FULL_WORD_MULTIPLIER;
                                 addWord(mWord, depth + 1, finalFreq);
                             }
                         }
@@ -319,190 +263,4 @@ UnigramDictionary::getWordsRec(int pos, int depth, int maxDepth, bool completion
     }
 }
 
-int
-UnigramDictionary::getBigramAddress(int *pos, bool advance)
-{
-    int address = 0;
-
-    address += (DICT[*pos] & 0x3F) << 16;
-    address += (DICT[*pos + 1] & 0xFF) << 8;
-    address += (DICT[*pos + 2] & 0xFF);
-
-    if (advance) {
-        *pos += 3;
-    }
-
-    return address;
-}
-
-int
-UnigramDictionary::getBigramFreq(int *pos)
-{
-    int freq = DICT[(*pos)++] & FLAG_BIGRAM_FREQ;
-
-    return freq;
-}
-
-
-int
-UnigramDictionary::getBigrams(unsigned short *prevWord, int prevWordLength, int *codes, int codesSize,
-        unsigned short *bigramChars, int *bigramFreq, int maxWordLength, int maxBigrams,
-        int maxAlternatives)
-{
-    mBigramFreq = bigramFreq;
-    mBigramChars = bigramChars;
-    mInputCodes = codes;
-    mInputLength = codesSize;
-    mMaxBigrams = maxBigrams;
-
-    if (HAS_BIGRAM && IS_LATEST_DICT_VERSION) {
-        int pos = mParentDictionary->isValidWordRec(
-                DICTIONARY_HEADER_SIZE, prevWord, 0, prevWordLength);
-        LOGI("Pos -> %d\n", pos);
-        if (pos < 0) {
-            return 0;
-        }
-
-        int bigramCount = 0;
-        int bigramExist = (DICT[pos] & FLAG_BIGRAM_READ);
-        if (bigramExist > 0) {
-            int nextBigramExist = 1;
-            while (nextBigramExist > 0 && bigramCount < maxBigrams) {
-                int bigramAddress = getBigramAddress(&pos, true);
-                int frequency = (FLAG_BIGRAM_FREQ & DICT[pos]);
-                // search for all bigrams and store them
-                searchForTerminalNode(bigramAddress, frequency);
-                nextBigramExist = (DICT[pos++] & FLAG_BIGRAM_CONTINUED);
-                bigramCount++;
-            }
-        }
-
-        return bigramCount;
-    }
-    return 0;
-}
-
-void
-UnigramDictionary::searchForTerminalNode(int addressLookingFor, int frequency)
-{
-    // track word with such address and store it in an array
-    unsigned short word[MAX_WORD_LENGTH];
-
-    int pos;
-    int followDownBranchAddress = DICTIONARY_HEADER_SIZE;
-    bool found = false;
-    char followingChar = ' ';
-    int depth = -1;
-
-    while(!found) {
-        bool followDownAddressSearchStop = false;
-        bool firstAddress = true;
-        bool haveToSearchAll = true;
-
-        if (depth >= 0) {
-            word[depth] = (unsigned short) followingChar;
-        }
-        pos = followDownBranchAddress; // pos start at count
-        int count = DICT[pos] & 0xFF;
-        LOGI("count - %d\n",count);
-        pos++;
-        for (int i = 0; i < count; i++) {
-            // pos at data
-            pos++;
-            // pos now at flag
-            if (!getFirstBitOfByte(&pos)) { // non-terminal
-                if (!followDownAddressSearchStop) {
-                    int addr = getBigramAddress(&pos, false);
-                    if (addr > addressLookingFor) {
-                        followDownAddressSearchStop = true;
-                        if (firstAddress) {
-                            firstAddress = false;
-                            haveToSearchAll = true;
-                        } else if (!haveToSearchAll) {
-                            break;
-                        }
-                    } else {
-                        followDownBranchAddress = addr;
-                        followingChar = (char)(0xFF & DICT[pos-1]);
-                        if (firstAddress) {
-                            firstAddress = false;
-                            haveToSearchAll = false;
-                        }
-                    }
-                }
-                pos += 3;
-            } else if (getFirstBitOfByte(&pos)) { // terminal
-                if (addressLookingFor == (pos-1)) { // found !!
-                    depth++;
-                    word[depth] = (0xFF & DICT[pos-1]);
-                    found = true;
-                    break;
-                }
-                if (getSecondBitOfByte(&pos)) { // address + freq (4 byte)
-                    if (!followDownAddressSearchStop) {
-                        int addr = getBigramAddress(&pos, false);
-                        if (addr > addressLookingFor) {
-                            followDownAddressSearchStop = true;
-                            if (firstAddress) {
-                                firstAddress = false;
-                                haveToSearchAll = true;
-                            } else if (!haveToSearchAll) {
-                                break;
-                            }
-                        } else {
-                            followDownBranchAddress = addr;
-                            followingChar = (char)(0xFF & DICT[pos-1]);
-                            if (firstAddress) {
-                                firstAddress = false;
-                                haveToSearchAll = true;
-                            }
-                        }
-                    }
-                    pos += 4;
-                } else { // freq only (2 byte)
-                    pos += 2;
-                }
-
-                // skipping bigram
-                int bigramExist = (DICT[pos] & FLAG_BIGRAM_READ);
-                if (bigramExist > 0) {
-                    int nextBigramExist = 1;
-                    while (nextBigramExist > 0) {
-                        pos += 3;
-                        nextBigramExist = (DICT[pos++] & FLAG_BIGRAM_CONTINUED);
-                    }
-                } else {
-                    pos++;
-                }
-            }
-        }
-        depth++;
-        if (followDownBranchAddress == 0) {
-            LOGI("ERROR!!! Cannot find bigram!!");
-            break;
-        }
-    }
-    if (checkFirstCharacter(word)) {
-        addWordBigram(word, depth, frequency);
-    }
-}
-
-bool
-UnigramDictionary::checkFirstCharacter(unsigned short *word)
-{
-    // Checks whether this word starts with same character or neighboring characters of
-    // what user typed.
-
-    int *inputCodes = mInputCodes;
-    int maxAlt = MAX_ALTERNATIVES;
-    while (maxAlt > 0) {
-        if ((unsigned int) *inputCodes == (unsigned int) *word) {
-            return true;
-        }
-        inputCodes++;
-        maxAlt--;
-    }
-    return false;
-}
-
 } // namespace latinime

native/src/unigram_dictionary.h

@@ -24,63 +24,42 @@ namespace latinime {
 class UnigramDictionary {
 public:
     UnigramDictionary(const unsigned char *dict, int typedLetterMultipler, int fullWordMultiplier,
-            int maxWordLength, int maxWords, int maxAlternatives,  const bool isLatestDictVersion,
-            const bool hasBigram, Dictionary *parentDictionary);
+            int maxWordLength, int maxWords, int maxAlternatives,  const bool isLatestDictVersion);
     int getSuggestions(int *codes, int codesSize, unsigned short *outWords, int *frequencies,
             int *nextLetters, int nextLettersSize);
-    int getBigrams(unsigned short *word, int length, int *codes, int codesSize,
-            unsigned short *outWords, int *frequencies, int maxWordLength, int maxBigrams,
-            int maxAlternatives);
     ~UnigramDictionary();
 
 private:
     void initSuggestions(int *codes, int codesSize, unsigned short *outWords, int *frequencies);
-    int getSuggestionCandidates(int inputLength, int skipPos, int *nextLetters, int nextLettersSize);
+    int getSuggestionCandidates(int inputLength, int skipPos, int *nextLetters,
+            int nextLettersSize);
     void getVersionNumber();
     bool checkIfDictVersionIsLatest();
     int getAddress(int *pos);
-    int getBigramAddress(int *pos, bool advance);
     int getFreq(int *pos);
-    int getBigramFreq(int *pos);
-    void searchForTerminalNode(int address, int frequency);
-
-    bool getFirstBitOfByte(int *pos) { return (DICT[*pos] & 0x80) > 0; }
-    bool getSecondBitOfByte(int *pos) { return (DICT[*pos] & 0x40) > 0; }
-    bool getTerminal(int *pos) { return (DICT[*pos] & FLAG_TERMINAL_MASK) > 0; }
     int wideStrLen(unsigned short *str);
 
     bool sameAsTyped(unsigned short *word, int length);
-    bool checkFirstCharacter(unsigned short *word);
     bool addWord(unsigned short *word, int length, int frequency);
-    bool addWordBigram(unsigned short *word, int length, int frequency);
     unsigned short toLowerCase(unsigned short c);
     void getWordsRec(int pos, int depth, int maxDepth, bool completion, int frequency,
             int inputIndex, int diffs, int skipPos, int *nextLetters, int nextLettersSize);
     void registerNextLetter(unsigned short c, int *nextLetters, int nextLettersSize);
 
     const unsigned char *DICT;
-
     const int MAX_WORDS;
     const int MAX_WORD_LENGTH;
     const int MAX_ALTERNATIVES;
     const bool IS_LATEST_DICT_VERSION;
-    const bool HAS_BIGRAM;
+    const int TYPED_LETTER_MULTIPLIER;
+    const int FULL_WORD_MULTIPLIER;
 
-    Dictionary *mParentDictionary;
     int *mFrequencies;
-    int *mBigramFreq;
-    int mMaxBigrams;
     unsigned short *mOutputChars;
-    unsigned short *mBigramChars;
     int *mInputCodes;
     int mInputLength;
     unsigned short mWord[128];
     int mMaxEditDistance;
-
-    int mFullWordMultiplier;
-    int mTypedLetterMultiplier;
-    int mVersion;
-    int mBigram;
 };
 
 // ----------------------------------------------------------------------------