(Step2)Move functions related to proximity to proximity_info.cpp
Change-Id: Iae0eb2a5cd758bda820fa42b4bc3eb3d2665bf96
diff --git a/native/src/proximity_info.cpp b/native/src/proximity_info.cpp
index ebf83a7..c45393f 100644
--- a/native/src/proximity_info.cpp
+++ b/native/src/proximity_info.cpp
@@ -19,6 +19,7 @@
#define LOG_TAG "LatinIME: proximity_info.cpp"
+#include "dictionary.h"
#include "proximity_info.h"
namespace latinime {
@@ -69,10 +70,82 @@
mInputLength = inputLength;
}
-const int* ProximityInfo::getProximityCharsAt(const int index) const {
+inline const int* ProximityInfo::getProximityCharsAt(const int index) const {
return mInputCodes + (index * MAX_PROXIMITY_CHARS_SIZE);
}
+unsigned short ProximityInfo::getPrimaryCharAt(const int index) const {
+ return getProximityCharsAt(index)[0];
+}
+
+bool ProximityInfo::existsCharInProximityAt(const int index, const int c) const {
+ const int *chars = getProximityCharsAt(index);
+ int i = 0;
+ while (chars[i] > 0 && i < MAX_PROXIMITY_CHARS_SIZE) {
+ if (chars[i++] == c) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool ProximityInfo::existsAdjacentProximityChars(const int index) const {
+ if (index < 0 || index >= mInputLength) return false;
+ const int currentChar = getPrimaryCharAt(index);
+ const int leftIndex = index - 1;
+ if (leftIndex >= 0 && existsCharInProximityAt(leftIndex, currentChar)) {
+ return true;
+ }
+ const int rightIndex = index + 1;
+ if (rightIndex < mInputLength && existsCharInProximityAt(rightIndex, currentChar)) {
+ return true;
+ }
+ return false;
+}
+
+// In the following function, c is the current character of the dictionary word
+// currently examined.
+// currentChars is an array containing the keys close to the character the
+// user actually typed at the same position. We want to see if c is in it: if so,
+// then the word contains at that position a character close to what the user
+// typed.
+// What the user typed is actually the first character of the array.
+// Notice : accented characters do not have a proximity list, so they are alone
+// in their list. The non-accented version of the character should be considered
+// "close", but not the other keys close to the non-accented version.
+ProximityInfo::ProximityType ProximityInfo::getMatchedProximityId(
+ const int index, const unsigned short c, const int skipPos,
+ const int excessivePos, const int transposedPos) const {
+ const int *currentChars = getProximityCharsAt(index);
+ const unsigned short baseLowerC = Dictionary::toBaseLowerCase(c);
+
+ // The first char in the array is what user typed. If it matches right away,
+ // that means the user typed that same char for this pos.
+ if (currentChars[0] == baseLowerC || currentChars[0] == c)
+ return SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR;
+
+ // If one of those is true, we should not check for close characters at all.
+ if (skipPos >= 0 || excessivePos >= 0 || transposedPos >= 0)
+ return UNRELATED_CHAR;
+
+ // If the non-accented, lowercased version of that first character matches c,
+ // then we have a non-accented version of the accented character the user
+ // typed. Treat it as a close char.
+ if (Dictionary::toBaseLowerCase(currentChars[0]) == baseLowerC)
+ return NEAR_PROXIMITY_CHAR;
+
+ // Not an exact nor an accent-alike match: search the list of close keys
+ int j = 1;
+ while (currentChars[j] > 0 && j < MAX_PROXIMITY_CHARS_SIZE) {
+ const bool matched = (currentChars[j] == baseLowerC || currentChars[j] == c);
+ if (matched) return NEAR_PROXIMITY_CHAR;
+ ++j;
+ }
+
+ // Was not included, signal this as an unrelated character.
+ return UNRELATED_CHAR;
+}
+
bool ProximityInfo::sameAsTyped(const unsigned short *word, int length) const {
if (length != mInputLength) {
return false;