am 618a949f: Merge "Use SuggestionResults to get suggestion."

* commit '618a949f9dd751236b4d74d293ca401002bad59d':
  Use SuggestionResults to get suggestion.

native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp

@@ -199,47 +199,30 @@ static void latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jclass clazz,
         ASSERT(false);
         return;
     }
-    int outputCodePoints[outputCodePointsLength];
-    int scores[scoresLength];
-    const jsize spaceIndicesLength = env->GetArrayLength(outSpaceIndicesArray);
-    int spaceIndices[spaceIndicesLength];
-    const jsize outputTypesLength = env->GetArrayLength(outTypesArray);
-    int outputTypes[outputTypesLength];
     const jsize outputAutoCommitFirstWordConfidenceLength =
             env->GetArrayLength(outAutoCommitFirstWordConfidenceArray);
-    // We only use the first result, as obviously we will only ever autocommit the first one
     ASSERT(outputAutoCommitFirstWordConfidenceLength == 1);
-    int outputAutoCommitFirstWordConfidence[outputAutoCommitFirstWordConfidenceLength];
+    if (outputAutoCommitFirstWordConfidenceLength != 1) {
-    memset(outputCodePoints, 0, sizeof(outputCodePoints));
+        // We only use the first result, as obviously we will only ever autocommit the first one
-    memset(scores, 0, sizeof(scores));
+        AKLOGE("Invalid outputAutoCommitFirstWordConfidenceLength: %d",
-    memset(spaceIndices, 0, sizeof(spaceIndices));
+                outputAutoCommitFirstWordConfidenceLength);
-    memset(outputTypes, 0, sizeof(outputTypes));
+        ASSERT(false);
-    memset(outputAutoCommitFirstWordConfidence, 0, sizeof(outputAutoCommitFirstWordConfidence));
-
-    if (givenSuggestOptions.isGesture() || inputSize > 0) {
-        // TODO: Use SuggestionResults to return suggestions.
-        count = dictionary->getSuggestions(pInfo, traverseSession, xCoordinates, yCoordinates,
-                times, pointerIds, inputCodePoints, inputSize, prevWordCodePoints,
-                prevWordCodePointsLength, &givenSuggestOptions, outputCodePoints,
-                scores, spaceIndices, outputTypes, outputAutoCommitFirstWordConfidence);
-    } else {
-        SuggestionResults suggestionResults(MAX_RESULTS);
-        dictionary->getPredictions(prevWordCodePoints, prevWordCodePointsLength,
-                &suggestionResults);
-        suggestionResults.outputSuggestions(env, outSuggestionCount, outCodePointsArray,
-                outScoresArray, outSpaceIndicesArray, outTypesArray,
-                outAutoCommitFirstWordConfidenceArray);
         return;
     }
 
-    // Copy back the output values
+    SuggestionResults suggestionResults(MAX_RESULTS);
-    env->SetIntArrayRegion(outSuggestionCount, 0, 1 /* len */, &count);
+    if (givenSuggestOptions.isGesture() || inputSize > 0) {
-    env->SetIntArrayRegion(outCodePointsArray, 0, outputCodePointsLength, outputCodePoints);
+        // TODO: Use SuggestionResults to return suggestions.
-    env->SetIntArrayRegion(outScoresArray, 0, scoresLength, scores);
+        dictionary->getSuggestions(pInfo, traverseSession, xCoordinates, yCoordinates,
-    env->SetIntArrayRegion(outSpaceIndicesArray, 0, spaceIndicesLength, spaceIndices);
+                times, pointerIds, inputCodePoints, inputSize, prevWordCodePoints,
-    env->SetIntArrayRegion(outTypesArray, 0, outputTypesLength, outputTypes);
+                prevWordCodePointsLength, &givenSuggestOptions, &suggestionResults);
-    env->SetIntArrayRegion(outAutoCommitFirstWordConfidenceArray, 0,
+    } else {
-            outputAutoCommitFirstWordConfidenceLength, outputAutoCommitFirstWordConfidence);
+        dictionary->getPredictions(prevWordCodePoints, prevWordCodePointsLength,
+                &suggestionResults);
+    }
+    suggestionResults.outputSuggestions(env, outSuggestionCount, outCodePointsArray,
+            outScoresArray, outSpaceIndicesArray, outTypesArray,
+            outAutoCommitFirstWordConfidenceArray);
 }
 
 static jint latinime_BinaryDictionary_getProbability(JNIEnv *env, jclass clazz, jlong dict,

native/jni/src/defines.h

@@ -103,7 +103,8 @@ AK_FORCE_INLINE static int intArrayToCharArray(const int *const source, const in
 #define AKLOGI(fmt, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##__VA_ARGS__)
 #endif // defined(HOST_TOOL)
 
-#define DUMP_RESULT(words, frequencies) do { dumpResult(words, frequencies); } while (0)
+#define DUMP_SUGGESTION(words, frequencies, index, score) \
+        do { dumpWordInfo(words, frequencies, index, score); } while (0)
 #define DUMP_WORD(word, length) do { dumpWord(word, length); } while (0)
 #define INTS_TO_CHARS(input, length, output, outlength) do { \
         intArrayToCharArray(input, length, output, outlength); } while (0)
@@ -165,7 +166,7 @@ static inline void showStackTrace() {
 #else // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
 #define AKLOGE(fmt, ...)
 #define AKLOGI(fmt, ...)
-#define DUMP_RESULT(words, frequencies)
+#define DUMP_SUGGESTION(words, frequencies, index, score)
 #define DUMP_WORD(word, length)
 #undef DO_ASSERT_TEST
 #define ASSERT(success)

native/jni/src/suggest/core/dictionary/dictionary.cpp

@@ -22,6 +22,7 @@
 
 #include "defines.h"
 #include "suggest/core/policy/dictionary_header_structure_policy.h"
+#include "suggest/core/result/suggestion_results.h"
 #include "suggest/core/session/dic_traverse_session.h"
 #include "suggest/core/suggest.h"
 #include "suggest/core/suggest_options.h"
@@ -43,34 +44,25 @@ Dictionary::Dictionary(JNIEnv *env, DictionaryStructureWithBufferPolicy::Structu
     logDictionaryInfo(env);
 }
 
-int Dictionary::getSuggestions(ProximityInfo *proximityInfo, DicTraverseSession *traverseSession,
+void Dictionary::getSuggestions(ProximityInfo *proximityInfo, DicTraverseSession *traverseSession,
         int *xcoordinates, int *ycoordinates, int *times, int *pointerIds, int *inputCodePoints,
         int inputSize, int *prevWordCodePoints, int prevWordLength,
-        const SuggestOptions *const suggestOptions, int *outWords, int *outputScores,
+        const SuggestOptions *const suggestOptions,
-        int *spaceIndices, int *outputTypes, int *outputAutoCommitFirstWordConfidence) const {
+        SuggestionResults *const outSuggestionResults) const {
     TimeKeeper::setCurrentTime();
-    int result = 0;
+    DicTraverseSession::initSessionInstance(
+            traverseSession, this, prevWordCodePoints, prevWordLength, suggestOptions);
     if (suggestOptions->isGesture()) {
-        DicTraverseSession::initSessionInstance(
+        mGestureSuggest->getSuggestions(proximityInfo, traverseSession, xcoordinates,
-                traverseSession, this, prevWordCodePoints, prevWordLength, suggestOptions);
-        result = mGestureSuggest->getSuggestions(proximityInfo, traverseSession, xcoordinates,
-                ycoordinates, times, pointerIds, inputCodePoints, inputSize, outWords,
-                outputScores, spaceIndices, outputTypes, outputAutoCommitFirstWordConfidence);
-        if (DEBUG_DICT) {
-            DUMP_RESULT(outWords, outputScores);
-        }
-        return result;
-    } else {
-        DicTraverseSession::initSessionInstance(
-                traverseSession, this, prevWordCodePoints, prevWordLength, suggestOptions);
-        result = mTypingSuggest->getSuggestions(proximityInfo, traverseSession, xcoordinates,
                 ycoordinates, times, pointerIds, inputCodePoints, inputSize,
-                outWords, outputScores, spaceIndices, outputTypes,
+                outSuggestionResults);
-                outputAutoCommitFirstWordConfidence);
+    } else {
-        if (DEBUG_DICT) {
+        mTypingSuggest->getSuggestions(proximityInfo, traverseSession, xcoordinates,
-            DUMP_RESULT(outWords, outputScores);
+                ycoordinates, times, pointerIds, inputCodePoints, inputSize,
-        }
+                outSuggestionResults);
-        return result;
+    }
+    if (DEBUG_DICT) {
+        outSuggestionResults->dumpSuggestions();
     }
 }
 

native/jni/src/suggest/core/dictionary/dictionary.h

@@ -62,11 +62,11 @@ class Dictionary {
     Dictionary(JNIEnv *env, DictionaryStructureWithBufferPolicy::StructurePolicyPtr
             dictionaryStructureWithBufferPolicy);
 
-    int getSuggestions(ProximityInfo *proximityInfo, DicTraverseSession *traverseSession,
+    void getSuggestions(ProximityInfo *proximityInfo, DicTraverseSession *traverseSession,
             int *xcoordinates, int *ycoordinates, int *times, int *pointerIds, int *inputCodePoints,
             int inputSize, int *prevWordCodePoints, int prevWordLength,
-            const SuggestOptions *const suggestOptions, int *outWords, int *outputScores,
+            const SuggestOptions *const suggestOptions,
-            int *spaceIndices, int *outputTypes, int *outputAutoCommitFirstWordConfidence) const;
+            SuggestionResults *const outSuggestionResults) const;
 
     void getPredictions(const int *word, int length,
             SuggestionResults *const outSuggestionResults) const;

native/jni/src/suggest/core/policy/scoring.h

@@ -23,6 +23,7 @@ namespace latinime {
 
 class DicNode;
 class DicTraverseSession;
+class SuggestionResults;
 
 // This class basically tweaks suggestions and distances apart from CompoundDistance
 class Scoring {
@@ -30,11 +31,8 @@ class Scoring {
     virtual int calculateFinalScore(const float compoundDistance, const int inputSize,
             const ErrorTypeUtils::ErrorType containedErrorTypes, const bool forceCommit,
             const bool boostExactMatches) const = 0;
-    virtual bool getMostProbableString(const DicTraverseSession *const traverseSession,
+    virtual void getMostProbableString(const DicTraverseSession *const traverseSession,
-            const int terminalSize, const float languageWeight, int *const outputCodePoints,
+            const float languageWeight, SuggestionResults *const outSuggestionResults) const = 0;
-            int *const type, int *const freq) const = 0;
-    virtual void safetyNetForMostProbableString(const int scoreCount,
-            const int maxScore, int *const outputCodePoints, int *const scores) const = 0;
     virtual float getAdjustedLanguageWeight(DicTraverseSession *const traverseSession,
             DicNode *const terminals, const int size) const = 0;
     virtual float getDoubleLetterDemotionDistanceCost(

native/jni/src/suggest/core/result/suggestion_results.cpp

@@ -54,13 +54,23 @@ void SuggestionResults::outputSuggestions(JNIEnv *env, jintArray outSuggestionCo
 
 void SuggestionResults::addPrediction(const int *const codePoints, const int codePointCount,
         const int probability) {
-    if (codePointCount <= 0 || codePointCount > MAX_WORD_LENGTH
+    if (probability == NOT_A_PROBABILITY) {
-            || probability == NOT_A_PROBABILITY) {
         // Invalid word.
         return;
     }
-    // Use probability as a score of the word.
+    addSuggestion(codePoints, codePointCount, probability, Dictionary::KIND_PREDICTION,
-    const int score = probability;
+            NOT_AN_INDEX, NOT_A_FIRST_WORD_CONFIDENCE);
+}
+
+void SuggestionResults::addSuggestion(const int *const codePoints, const int codePointCount,
+        const int score, const int type, const int indexToPartialCommit,
+        const int autocimmitFirstWordConfindence) {
+    if (codePointCount <= 0 || codePointCount > MAX_WORD_LENGTH) {
+        // Invalid word.
+        AKLOGE("Invalid word is added to the suggestion results. codePointCount: %d",
+                codePointCount);
+        return;
+    }
     if (getSuggestionCount() >= mMaxSuggestionCount) {
         const SuggestedWord &mWorstSuggestion = mSuggestedWords.top();
         if (score > mWorstSuggestion.getScore() || (score == mWorstSuggestion.getScore()
@@ -70,8 +80,31 @@ void SuggestionResults::addPrediction(const int *const codePoints, const int cod
             return;
         }
     }
-    mSuggestedWords.push(SuggestedWord(codePoints, codePointCount, score,
+    mSuggestedWords.push(SuggestedWord(codePoints, codePointCount, score, type,
-            Dictionary::KIND_PREDICTION, NOT_AN_INDEX, NOT_A_FIRST_WORD_CONFIDENCE));
+            indexToPartialCommit, autocimmitFirstWordConfindence));
+}
+
+void SuggestionResults::getSortedScores(int *const outScores) const {
+    auto copyOfSuggestedWords = mSuggestedWords;
+    while (!copyOfSuggestedWords.empty()) {
+        const SuggestedWord &suggestedWord = copyOfSuggestedWords.top();
+        outScores[copyOfSuggestedWords.size() - 1] = suggestedWord.getScore();
+        copyOfSuggestedWords.pop();
+    }
+}
+
+void SuggestionResults::dumpSuggestions() const {
+    std::vector<SuggestedWord> suggestedWords;
+    auto copyOfSuggestedWords = mSuggestedWords;
+    while (!copyOfSuggestedWords.empty()) {
+        suggestedWords.push_back(copyOfSuggestedWords.top());
+        copyOfSuggestedWords.pop();
+    }
+    int index = 0;
+    for (auto it = suggestedWords.rbegin(); it != suggestedWords.rend(); ++it) {
+        DUMP_SUGGESTION(it->getCodePoint(), it->getCodePointCount(), index, it->getScore());
+        index++;
+    }
 }
 
 } // namespace latinime

native/jni/src/suggest/core/result/suggestion_results.h

@@ -35,8 +35,12 @@ class SuggestionResults {
     void outputSuggestions(JNIEnv *env, jintArray outSuggestionCount, jintArray outCodePointsArray,
             jintArray outScoresArray, jintArray outSpaceIndicesArray, jintArray outTypesArray,
             jintArray outAutoCommitFirstWordConfidenceArray);
-
     void addPrediction(const int *const codePoints, const int codePointCount, const int score);
+    void addSuggestion(const int *const codePoints, const int codePointCount,
+            const int score, const int type, const int indexToPartialCommit,
+            const int autocimmitFirstWordConfindence);
+    void getSortedScores(int *const outScores) const;
+    void dumpSuggestions() const;
 
     int getSuggestionCount() const {
         return mSuggestedWords.size();

native/jni/src/suggest/core/result/suggestions_output_utils.cpp

@@ -24,6 +24,7 @@
 #include "suggest/core/dictionary/dictionary.h"
 #include "suggest/core/dictionary/error_type_utils.h"
 #include "suggest/core/policy/scoring.h"
+#include "suggest/core/result/suggestion_results.h"
 #include "suggest/core/session/dic_traverse_session.h"
 
 namespace latinime {
@@ -31,10 +32,9 @@ namespace latinime {
 const int SuggestionsOutputUtils::MIN_LEN_FOR_MULTI_WORD_AUTOCORRECT = 16;
 
 // TODO: Split this method.
-/* static */ int SuggestionsOutputUtils::outputSuggestions(
+/* static */ void SuggestionsOutputUtils::outputSuggestions(
         const Scoring *const scoringPolicy, DicTraverseSession *traverseSession,
-        int *outputScores, int *outputCodePoints, int *outputIndicesToPartialCommit,
+        SuggestionResults *const outSuggestionResults) {
-        int *outputTypes, int *outputAutoCommitFirstWordConfidence) {
 #if DEBUG_EVALUATE_MOST_PROBABLE_STRING
     const int terminalSize = 0;
 #else
@@ -49,18 +49,6 @@ const int SuggestionsOutputUtils::MIN_LEN_FOR_MULTI_WORD_AUTOCORRECT = 16;
 
     const float languageWeight = scoringPolicy->getAdjustedLanguageWeight(
             traverseSession, terminals, terminalSize);
-
-    int outputWordIndex = 0;
-    // Insert most probable word at index == 0 as long as there is one terminal at least
-    const bool hasMostProbableString =
-            scoringPolicy->getMostProbableString(traverseSession, terminalSize, languageWeight,
-                    &outputCodePoints[0], &outputTypes[0], &outputScores[0]);
-    if (hasMostProbableString) {
-        outputIndicesToPartialCommit[outputWordIndex] = NOT_AN_INDEX;
-        ++outputWordIndex;
-    }
-
-    int maxScore = S_INT_MIN;
     // Force autocorrection for obvious long multi-word suggestions when the top suggestion is
     // a long multiple words suggestion.
     // TODO: Implement a smarter auto-commit method for handling multi-word suggestions.
@@ -75,16 +63,12 @@ const int SuggestionsOutputUtils::MIN_LEN_FOR_MULTI_WORD_AUTOCORRECT = 16;
     // TODO: have partial commit work even with multiple pointers.
     const bool outputSecondWordFirstLetterInputIndex =
             traverseSession->isOnlyOnePointerUsed(0 /* pointerId */);
-    if (terminalSize > 0) {
-        // If we have no suggestions, don't write this
-        outputAutoCommitFirstWordConfidence[0] =
-                computeFirstWordConfidence(&terminals[0]);
-    }
     const bool boostExactMatches = traverseSession->getDictionaryStructurePolicy()->
             getHeaderStructurePolicy()->shouldBoostExactMatches();
+
+    int codePoints[MAX_WORD_LENGTH];
     // Output suggestion results here
-    for (int terminalIndex = 0; terminalIndex < terminalSize && outputWordIndex < MAX_RESULTS;
+    for (int terminalIndex = 0; terminalIndex < terminalSize; ++terminalIndex) {
-            ++terminalIndex) {
         DicNode *terminalDicNode = &terminals[terminalIndex];
         if (DEBUG_GEO_FULL) {
             terminalDicNode->dump("OUT:");
@@ -118,25 +102,18 @@ const int SuggestionsOutputUtils::MIN_LEN_FOR_MULTI_WORD_AUTOCORRECT = 16;
                 (forceCommitMultiWords && terminalDicNode->hasMultipleWords())
                          || (isValidWord && scoringPolicy->doesAutoCorrectValidWord()),
                 boostExactMatches);
-        if (maxScore < finalScore && isValidWord) {
-            maxScore = finalScore;
-        }
 
         // Don't output invalid words. However, we still need to submit their shortcuts if any.
         if (isValidWord) {
-            outputTypes[outputWordIndex] = Dictionary::KIND_CORRECTION | outputTypeFlags;
+            terminalDicNode->outputResult(codePoints);
-            outputScores[outputWordIndex] = finalScore;
+            const int indexToPartialCommit = outputSecondWordFirstLetterInputIndex ?
-            if (outputSecondWordFirstLetterInputIndex) {
+                    terminalDicNode->getSecondWordFirstInputIndex(
-                outputIndicesToPartialCommit[outputWordIndex] =
+                            traverseSession->getProximityInfoState(0)) :
-                        terminalDicNode->getSecondWordFirstInputIndex(
+                    NOT_AN_INDEX;
-                                traverseSession->getProximityInfoState(0));
+            outSuggestionResults->addSuggestion(codePoints,
-            } else {
+                    terminalDicNode->getTotalNodeCodePointCount(),
-                outputIndicesToPartialCommit[outputWordIndex] = NOT_AN_INDEX;
+                    finalScore, Dictionary::KIND_CORRECTION | outputTypeFlags,
-            }
+                    indexToPartialCommit, computeFirstWordConfidence(terminalDicNode));
-            // Populate the outputChars array with the suggested word.
-            const int startIndex = outputWordIndex * MAX_WORD_LENGTH;
-            terminalDicNode->outputResult(&outputCodePoints[startIndex]);
-            ++outputWordIndex;
         }
 
         if (!terminalDicNode->hasMultipleWords()) {
@@ -152,28 +129,11 @@ const int SuggestionsOutputUtils::MIN_LEN_FOR_MULTI_WORD_AUTOCORRECT = 16;
                              traverseSession->getInputSize(),
                              terminalDicNode->getContainedErrorTypes(),
                              true /* forceCommit */, boostExactMatches) : finalScore;
-            const int updatedOutputWordIndex = outputShortcuts(&shortcutIt,
+            outputShortcuts(&shortcutIt, shortcutBaseScore, sameAsTyped, outSuggestionResults);
-                    outputWordIndex, shortcutBaseScore, outputCodePoints, outputScores, outputTypes,
-                    sameAsTyped);
-            const int secondWordFirstInputIndex = terminalDicNode->getSecondWordFirstInputIndex(
-                    traverseSession->getProximityInfoState(0));
-            for (int i = outputWordIndex; i < updatedOutputWordIndex; ++i) {
-                if (outputSecondWordFirstLetterInputIndex) {
-                    outputIndicesToPartialCommit[i] = secondWordFirstInputIndex;
-                } else {
-                    outputIndicesToPartialCommit[i] = NOT_AN_INDEX;
-                }
-            }
-            outputWordIndex = updatedOutputWordIndex;
         }
         DicNode::managedDelete(terminalDicNode);
     }
-
+    scoringPolicy->getMostProbableString(traverseSession, languageWeight, outSuggestionResults);
-    if (hasMostProbableString) {
-        scoringPolicy->safetyNetForMostProbableString(outputWordIndex, maxScore,
-                &outputCodePoints[0], outputScores);
-    }
-    return outputWordIndex;
 }
 
 /* static */ int SuggestionsOutputUtils::computeFirstWordConfidence(
@@ -228,12 +188,11 @@ const int SuggestionsOutputUtils::MIN_LEN_FOR_MULTI_WORD_AUTOCORRECT = 16;
     return distanceContribution + lengthContribution + spaceContribution;
 }
 
-/* static */ int SuggestionsOutputUtils::outputShortcuts(
+/* static */ void SuggestionsOutputUtils::outputShortcuts(
-        BinaryDictionaryShortcutIterator *const shortcutIt,
+        BinaryDictionaryShortcutIterator *const shortcutIt, const int finalScore,
-        int outputWordIndex, const int finalScore, int *const outputCodePoints,
+        const bool sameAsTyped, SuggestionResults *const outSuggestionResults) {
-        int *const outputScores, int *const outputTypes, const bool sameAsTyped) {
     int shortcutTarget[MAX_WORD_LENGTH];
-    while (shortcutIt->hasNextShortcutTarget() && outputWordIndex < MAX_RESULTS) {
+    while (shortcutIt->hasNextShortcutTarget()) {
         bool isWhilelist;
         int shortcutTargetStringLength;
         shortcutIt->nextShortcutTarget(MAX_WORD_LENGTH, shortcutTarget,
@@ -250,15 +209,9 @@ const int SuggestionsOutputUtils::MIN_LEN_FOR_MULTI_WORD_AUTOCORRECT = 16;
             shortcutScore = std::max(S_INT_MIN + 1, shortcutScore) - 1;
             kind = Dictionary::KIND_SHORTCUT;
         }
-        outputTypes[outputWordIndex] = kind;
+        outSuggestionResults->addSuggestion(shortcutTarget, shortcutTargetStringLength,
-        outputScores[outputWordIndex] = shortcutScore;
+                std::max(S_INT_MIN + 1, shortcutScore) - 1, kind, NOT_AN_INDEX,
-        outputScores[outputWordIndex] = std::max(S_INT_MIN + 1, shortcutScore) - 1;
+                NOT_A_FIRST_WORD_CONFIDENCE);
-        const int startIndex2 = outputWordIndex * MAX_WORD_LENGTH;
-        // Copy shortcut target code points to the output buffer.
-        memmove(&outputCodePoints[startIndex2], shortcutTarget,
-                shortcutTargetStringLength * sizeof(shortcutTarget[0]));
-        ++outputWordIndex;
     }
-    return outputWordIndex;
 }
 } // namespace latinime

native/jni/src/suggest/core/result/suggestions_output_utils.h

@@ -25,16 +25,15 @@ class BinaryDictionaryShortcutIterator;
 class DicNode;
 class DicTraverseSession;
 class Scoring;
+class SuggestionResults;
 
 class SuggestionsOutputUtils {
  public:
     /**
      * Outputs the final list of suggestions (i.e., terminal nodes).
      */
-    static int outputSuggestions(const Scoring *const scoringPolicy,
+    static void outputSuggestions(const Scoring *const scoringPolicy,
-            DicTraverseSession *traverseSession, int *outputScores, int *outputCodePoints,
+            DicTraverseSession *traverseSession, SuggestionResults *const outSuggestionResults);
-            int *outputIndicesToPartialCommit, int *outputTypes,
-            int *outputAutoCommitFirstWordConfidence);
 
  private:
     DISALLOW_IMPLICIT_CONSTRUCTORS(SuggestionsOutputUtils);
@@ -44,9 +43,9 @@ class SuggestionsOutputUtils {
 
     static int computeFirstWordConfidence(const DicNode *const terminalDicNode);
 
-    static int outputShortcuts(BinaryDictionaryShortcutIterator *const shortcutIt,
+    static void outputShortcuts(BinaryDictionaryShortcutIterator *const shortcutIt,
-            int outputWordIndex, const int finalScore, int *const outputCodePoints,
+            const int finalScore, const bool sameAsTyped,
-            int *const outputScores, int *const outputTypes, const bool sameAsTyped);
+            SuggestionResults *const outSuggestionResults);
 };
 } // namespace latinime
 #endif // LATINIME_SUGGESTIONS_OUTPUT_UTILS

native/jni/src/suggest/core/suggest.cpp

@@ -42,10 +42,9 @@ const int Suggest::MIN_CONTINUOUS_SUGGESTION_INPUT_SIZE = 2;
  * automatically activated for sequential calls that share the same starting input.
  * TODO: Stop detecting continuous suggestion. Start using traverseSession instead.
  */
-int Suggest::getSuggestions(ProximityInfo *pInfo, void *traverseSession,
+void Suggest::getSuggestions(ProximityInfo *pInfo, void *traverseSession,
         int *inputXs, int *inputYs, int *times, int *pointerIds, int *inputCodePoints,
-        int inputSize, int *outWords, int *outputScores, int *outputIndices,
+        int inputSize, SuggestionResults *const outSuggestionResults) const {
-        int *outputTypes, int *outputAutoCommitFirstWordConfidence) const {
     PROF_OPEN;
     PROF_START(0);
     const float maxSpatialDistance = TRAVERSAL->getMaxSpatialDistance();
@@ -66,11 +65,9 @@ int Suggest::getSuggestions(ProximityInfo *pInfo, void *traverseSession,
     }
     PROF_END(1);
     PROF_START(2);
-    const int size = SuggestionsOutputUtils::outputSuggestions(SCORING, tSession, outputScores,
+    SuggestionsOutputUtils::outputSuggestions(SCORING, tSession, outSuggestionResults);
-            outWords, outputIndices, outputTypes, outputAutoCommitFirstWordConfidence);
     PROF_END(2);
     PROF_CLOSE;
-    return size;
 }
 
 /**

native/jni/src/suggest/core/suggest.h

@@ -36,6 +36,7 @@ class DicNode;
 class DicTraverseSession;
 class ProximityInfo;
 class Scoring;
+class SuggestionResults;
 class Traversal;
 class Weighting;
 
@@ -46,10 +47,9 @@ class Suggest : public SuggestInterface {
               SCORING(suggestPolicy ? suggestPolicy->getScoring() : nullptr),
               WEIGHTING(suggestPolicy ? suggestPolicy->getWeighting() : nullptr) {}
     AK_FORCE_INLINE virtual ~Suggest() {}
-    int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs, int *inputYs,
+    void getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs, int *inputYs,
-            int *times, int *pointerIds, int *inputCodePoints, int inputSize, int *outWords,
+            int *times, int *pointerIds, int *inputCodePoints, int inputSize,
-            int *outputScores, int *outputIndices, int *outputTypes,
+            SuggestionResults *const outSuggestionResults) const;
-            int *outputAutoCommitFirstWordConfidence) const;
 
  private:
     DISALLOW_IMPLICIT_CONSTRUCTORS(Suggest);

native/jni/src/suggest/core/suggest_interface.h

@@ -22,13 +22,13 @@
 namespace latinime {
 
 class ProximityInfo;
+class SuggestionResults;
 
 class SuggestInterface {
  public:
-    virtual int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs,
+    virtual void getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs,
             int *inputYs, int *times, int *pointerIds, int *inputCodePoints, int inputSize,
-            int *outWords, int *outputScores, int *outputIndices, int *outputTypes,
+            SuggestionResults *const suggestionResults) const = 0;
-            int *outputAutoCommitFirstWordConfidence) const = 0;
     SuggestInterface() {}
     virtual ~SuggestInterface() {}
  private:

native/jni/src/suggest/policyimpl/typing/typing_scoring.h

@@ -32,15 +32,8 @@ class TypingScoring : public Scoring {
  public:
     static const TypingScoring *getInstance() { return &sInstance; }
 
-    AK_FORCE_INLINE bool getMostProbableString(const DicTraverseSession *const traverseSession,
+    AK_FORCE_INLINE void getMostProbableString(const DicTraverseSession *const traverseSession,
-            const int terminalSize, const float languageWeight, int *const outputCodePoints,
+            const float languageWeight, SuggestionResults *const outSuggestionResults) const {}
-            int *const type, int *const freq) const {
-        return false;
-    }
-
-    AK_FORCE_INLINE void safetyNetForMostProbableString(const int scoreCount, const int maxScore,
-            int *const outputCodePoints, int *const scores) const {
-    }
 
     AK_FORCE_INLINE float getAdjustedLanguageWeight(DicTraverseSession *const traverseSession,
             DicNode *const terminals, const int size) const {