Merge "Merge NOT_A_VALID_WORD_POS into NOT_A_DICT_POS."
commit
8faa1a4482
|
@ -292,7 +292,6 @@ static inline void prof_out(void) {
|
|||
// of the binary dictionary where a {key,value} string pair scheme is used.
|
||||
#define LARGEST_INT_DIGIT_COUNT 11
|
||||
|
||||
#define NOT_A_VALID_WORD_POS (-99)
|
||||
#define NOT_A_CODE_POINT (-1)
|
||||
#define NOT_A_DISTANCE (-1)
|
||||
#define NOT_A_COORDINATE (-1)
|
||||
|
|
|
@ -112,7 +112,7 @@ class DicNode {
|
|||
mIsUsed = true;
|
||||
mIsCachedForNextSuggestion = false;
|
||||
mDicNodeProperties.init(
|
||||
NOT_A_VALID_WORD_POS /* pos */, rootGroupPos, NOT_A_CODE_POINT /* nodeCodePoint */,
|
||||
NOT_A_DICT_POS /* pos */, rootGroupPos, NOT_A_CODE_POINT /* nodeCodePoint */,
|
||||
NOT_A_PROBABILITY /* probability */, false /* isTerminal */,
|
||||
true /* hasChildren */, false /* isBlacklistedOrNotAWord */, 0 /* depth */,
|
||||
0 /* terminalDepth */);
|
||||
|
@ -125,7 +125,7 @@ class DicNode {
|
|||
mIsUsed = true;
|
||||
mIsCachedForNextSuggestion = dicNode->mIsCachedForNextSuggestion;
|
||||
mDicNodeProperties.init(
|
||||
NOT_A_VALID_WORD_POS /* pos */, rootGroupPos, NOT_A_CODE_POINT /* nodeCodePoint */,
|
||||
NOT_A_DICT_POS /* pos */, rootGroupPos, NOT_A_CODE_POINT /* nodeCodePoint */,
|
||||
NOT_A_PROBABILITY /* probability */, false /* isTerminal */,
|
||||
true /* hasChildren */, false /* isBlacklistedOrNotAWord */, 0 /* depth */,
|
||||
0 /* terminalDepth */);
|
||||
|
@ -234,7 +234,7 @@ class DicNode {
|
|||
}
|
||||
|
||||
bool isFirstWord() const {
|
||||
return mDicNodeState.mDicNodeStatePrevWord.getPrevWordNodePos() == NOT_A_VALID_WORD_POS;
|
||||
return mDicNodeState.mDicNodeStatePrevWord.getPrevWordNodePos() == NOT_A_DICT_POS;
|
||||
}
|
||||
|
||||
bool isCompletion(const int inputSize) const {
|
||||
|
|
|
@ -89,7 +89,7 @@ namespace latinime {
|
|||
const int unigramProbability = node->getProbability();
|
||||
const int wordPos = node->getPos();
|
||||
const int prevWordPos = node->getPrevWordPos();
|
||||
if (NOT_A_VALID_WORD_POS == wordPos || NOT_A_VALID_WORD_POS == prevWordPos) {
|
||||
if (NOT_A_DICT_POS == wordPos || NOT_A_DICT_POS == prevWordPos) {
|
||||
// Note: Normally wordPos comes from the dictionary and should never equal
|
||||
// NOT_A_VALID_WORD_POS.
|
||||
return dictionaryStructurePolicy->getProbability(unigramProbability,
|
||||
|
|
|
@ -29,7 +29,7 @@ class DicNodeStatePrevWord {
|
|||
public:
|
||||
AK_FORCE_INLINE DicNodeStatePrevWord()
|
||||
: mPrevWordCount(0), mPrevWordLength(0), mPrevWordStart(0), mPrevWordProbability(0),
|
||||
mPrevWordNodePos(NOT_A_VALID_WORD_POS) {
|
||||
mPrevWordNodePos(NOT_A_DICT_POS) {
|
||||
memset(mPrevWord, 0, sizeof(mPrevWord));
|
||||
memset(mPrevSpacePositions, 0, sizeof(mPrevSpacePositions));
|
||||
}
|
||||
|
@ -41,7 +41,7 @@ class DicNodeStatePrevWord {
|
|||
mPrevWordCount = 0;
|
||||
mPrevWordStart = 0;
|
||||
mPrevWordProbability = -1;
|
||||
mPrevWordNodePos = NOT_A_VALID_WORD_POS;
|
||||
mPrevWordNodePos = NOT_A_DICT_POS;
|
||||
memset(mPrevSpacePositions, 0, sizeof(mPrevSpacePositions));
|
||||
}
|
||||
|
||||
|
|
|
@ -116,7 +116,7 @@ int BigramDictionary::getPredictions(const int *prevWord, const int prevWordLeng
|
|||
mDictionaryStructurePolicy->getBigramsStructurePolicy(), pos);
|
||||
while (bigramsIt.hasNext()) {
|
||||
bigramsIt.next();
|
||||
if (bigramsIt.getBigramPos() == NOT_A_VALID_WORD_POS) {
|
||||
if (bigramsIt.getBigramPos() == NOT_A_DICT_POS) {
|
||||
continue;
|
||||
}
|
||||
const int codePointCount = mDictionaryStructurePolicy->
|
||||
|
@ -146,7 +146,7 @@ int BigramDictionary::getBigramListPositionForWord(const int *prevWord, const in
|
|||
if (0 >= prevWordLength) return NOT_A_DICT_POS;
|
||||
int pos = mDictionaryStructurePolicy->getTerminalNodePositionOfWord(prevWord, prevWordLength,
|
||||
forceLowerCaseSearch);
|
||||
if (NOT_A_VALID_WORD_POS == pos) return NOT_A_DICT_POS;
|
||||
if (NOT_A_DICT_POS == pos) return NOT_A_DICT_POS;
|
||||
return mDictionaryStructurePolicy->getBigramsPositionOfNode(pos);
|
||||
}
|
||||
|
||||
|
@ -157,7 +157,7 @@ bool BigramDictionary::isValidBigram(const int *word0, int length0, const int *w
|
|||
if (NOT_A_DICT_POS == pos) return false;
|
||||
int nextWordPos = mDictionaryStructurePolicy->getTerminalNodePositionOfWord(word1, length1,
|
||||
false /* forceLowerCaseSearch */);
|
||||
if (NOT_A_VALID_WORD_POS == nextWordPos) return false;
|
||||
if (NOT_A_DICT_POS == nextWordPos) return false;
|
||||
|
||||
BinaryDictionaryBigramsIterator bigramsIt(
|
||||
mDictionaryStructurePolicy->getBigramsStructurePolicy(), pos);
|
||||
|
|
|
@ -87,7 +87,7 @@ int Dictionary::getBigrams(const int *word, int length, int *outWords, int *freq
|
|||
int Dictionary::getProbability(const int *word, int length) const {
|
||||
int pos = getDictionaryStructurePolicy()->getTerminalNodePositionOfWord(word, length,
|
||||
false /* forceLowerCaseSearch */);
|
||||
if (NOT_A_VALID_WORD_POS == pos) {
|
||||
if (NOT_A_DICT_POS == pos) {
|
||||
return NOT_A_PROBABILITY;
|
||||
}
|
||||
return getDictionaryStructurePolicy()->getUnigramProbabilityOfPtNode(pos);
|
||||
|
|
|
@ -73,7 +73,7 @@ class MultiBigramMap {
|
|||
bigramsListPos);
|
||||
while (bigramsIt.hasNext()) {
|
||||
bigramsIt.next();
|
||||
if (bigramsIt.getBigramPos() == NOT_A_VALID_WORD_POS) {
|
||||
if (bigramsIt.getBigramPos() == NOT_A_DICT_POS) {
|
||||
continue;
|
||||
}
|
||||
mBigramMap[bigramsIt.getBigramPos()] = bigramsIt.getProbability();
|
||||
|
|
|
@ -35,13 +35,13 @@ void DicTraverseSession::init(const Dictionary *const dictionary, const int *pre
|
|||
->getMultiWordCostMultiplier();
|
||||
mSuggestOptions = suggestOptions;
|
||||
if (!prevWord) {
|
||||
mPrevWordPos = NOT_A_VALID_WORD_POS;
|
||||
mPrevWordPos = NOT_A_DICT_POS;
|
||||
return;
|
||||
}
|
||||
// TODO: merge following similar calls to getTerminalPosition into one case-insensitive call.
|
||||
mPrevWordPos = getDictionaryStructurePolicy()->getTerminalNodePositionOfWord(
|
||||
prevWord, prevWordLength, false /* forceLowerCaseSearch */);
|
||||
if (mPrevWordPos == NOT_A_VALID_WORD_POS) {
|
||||
if (mPrevWordPos == NOT_A_DICT_POS) {
|
||||
// Check bigrams for lower-cased previous word if original was not found. Useful for
|
||||
// auto-capitalized words like "The [current_word]".
|
||||
mPrevWordPos = getDictionaryStructurePolicy()->getTerminalNodePositionOfWord(
|
||||
|
|
|
@ -59,7 +59,7 @@ class DicTraverseSession {
|
|||
}
|
||||
|
||||
AK_FORCE_INLINE DicTraverseSession(JNIEnv *env, jstring localeStr, bool usesLargeCache)
|
||||
: mPrevWordPos(NOT_A_VALID_WORD_POS), mProximityInfo(0),
|
||||
: mPrevWordPos(NOT_A_DICT_POS), mProximityInfo(0),
|
||||
mDictionary(0), mSuggestOptions(0), mDicNodesCache(usesLargeCache),
|
||||
mMultiBigramMap(), mInputSize(0), mPartiallyCommited(false), mMaxPointerCount(1),
|
||||
mMultiWordCostMultiplier(1.0f) {
|
||||
|
|
|
@ -70,7 +70,7 @@ const int BigramListReadWriteUtils::ATTRIBUTE_ADDRESS_SHIFT = 4;
|
|||
break;
|
||||
}
|
||||
if (offset == 0) {
|
||||
return NOT_A_VALID_WORD_POS;
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
if (isOffsetNegative(flags)) {
|
||||
return origin - offset;
|
||||
|
|
|
@ -67,7 +67,7 @@ public:
|
|||
const int entryPos, const int targetPos, const int probability, const bool hasNext,
|
||||
BigramFlags *const outBigramFlags, uint32_t *const outOffset,
|
||||
int *const outOffsetFieldSize) {
|
||||
if (targetPos == NOT_A_VALID_WORD_POS) {
|
||||
if (targetPos == NOT_A_DICT_POS) {
|
||||
return false;
|
||||
}
|
||||
BigramFlags flags = probability & MASK_ATTRIBUTE_PROBABILITY;
|
||||
|
|
|
@ -31,7 +31,7 @@ void DynamicBigramListPolicy::getNextBigram(int *const outBigramPos, int *const
|
|||
BigramListReadWriteUtils::getFlagsAndForwardPointer(buffer, pos);
|
||||
int originalBigramPos = BigramListReadWriteUtils::getBigramAddressAndForwardPointer(
|
||||
buffer, flags, pos);
|
||||
if (usesAdditionalBuffer && originalBigramPos != NOT_A_VALID_WORD_POS) {
|
||||
if (usesAdditionalBuffer && originalBigramPos != NOT_A_DICT_POS) {
|
||||
originalBigramPos += mBuffer->getOriginalBufferSize();
|
||||
}
|
||||
*outBigramPos = followBigramLinkAndGetCurrentBigramPtNodePos(originalBigramPos);
|
||||
|
@ -66,7 +66,7 @@ bool DynamicBigramListPolicy::copyAllBigrams(int *const fromPos, int *const toPo
|
|||
flags = BigramListReadWriteUtils::getFlagsAndForwardPointer(buffer, fromPos);
|
||||
int originalBigramPos = BigramListReadWriteUtils::getBigramAddressAndForwardPointer(
|
||||
buffer, flags, fromPos);
|
||||
if (originalBigramPos == NOT_A_VALID_WORD_POS) {
|
||||
if (originalBigramPos == NOT_A_DICT_POS) {
|
||||
// skip invalid bigram entry.
|
||||
continue;
|
||||
}
|
||||
|
@ -172,7 +172,7 @@ bool DynamicBigramListPolicy::removeBigram(const int bigramListPos, const int ta
|
|||
}
|
||||
int originalBigramPos = BigramListReadWriteUtils::getBigramAddressAndForwardPointer(
|
||||
buffer, flags, &pos);
|
||||
if (usesAdditionalBuffer && originalBigramPos != NOT_A_VALID_WORD_POS) {
|
||||
if (usesAdditionalBuffer && originalBigramPos != NOT_A_DICT_POS) {
|
||||
originalBigramPos += mBuffer->getOriginalBufferSize();
|
||||
}
|
||||
const int bigramPos = followBigramLinkAndGetCurrentBigramPtNodePos(originalBigramPos);
|
||||
|
@ -192,8 +192,8 @@ bool DynamicBigramListPolicy::removeBigram(const int bigramListPos, const int ta
|
|||
|
||||
int DynamicBigramListPolicy::followBigramLinkAndGetCurrentBigramPtNodePos(
|
||||
const int originalBigramPos) const {
|
||||
if (originalBigramPos == NOT_A_VALID_WORD_POS) {
|
||||
return NOT_A_VALID_WORD_POS;
|
||||
if (originalBigramPos == NOT_A_DICT_POS) {
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
int currentPos = originalBigramPos;
|
||||
DynamicPatriciaTrieNodeReader nodeReader(mBuffer, this /* bigramsPolicy */, mShortcutPolicy);
|
||||
|
@ -206,7 +206,7 @@ int DynamicBigramListPolicy::followBigramLinkAndGetCurrentBigramPtNodePos(
|
|||
if (bigramLinkCount > BIGRAM_LINK_COUNT_LIMIT) {
|
||||
AKLOGI("Bigram link is invalid. start position: %d", bigramPos);
|
||||
ASSERT(false);
|
||||
return NOT_A_VALID_WORD_POS;
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
}
|
||||
return currentPos;
|
||||
|
|
|
@ -69,7 +69,7 @@ void DynamicPatriciaTrieNodeReader::fetchNodeInfoFromBufferAndProcessMovedNode(c
|
|||
if (usesAdditionalBuffer && mChildrenPos != NOT_A_DICT_POS) {
|
||||
mChildrenPos += mBuffer->getOriginalBufferSize();
|
||||
}
|
||||
if (mSiblingPos == NOT_A_VALID_WORD_POS && DynamicPatriciaTrieReadingUtils::isMoved(mFlags)) {
|
||||
if (mSiblingPos == NOT_A_DICT_POS && DynamicPatriciaTrieReadingUtils::isMoved(mFlags)) {
|
||||
mBigramLinkedNodePos = mChildrenPos;
|
||||
} else {
|
||||
mBigramLinkedNodePos = NOT_A_DICT_POS;
|
||||
|
@ -90,7 +90,7 @@ void DynamicPatriciaTrieNodeReader::fetchNodeInfoFromBufferAndProcessMovedNode(c
|
|||
mBigramPos = NOT_A_DICT_POS;
|
||||
}
|
||||
// Update siblingPos if needed.
|
||||
if (mSiblingPos == NOT_A_VALID_WORD_POS) {
|
||||
if (mSiblingPos == NOT_A_DICT_POS) {
|
||||
// Sibling position is the tail position of current node.
|
||||
mSiblingPos = pos;
|
||||
}
|
||||
|
@ -102,7 +102,7 @@ void DynamicPatriciaTrieNodeReader::fetchNodeInfoFromBufferAndProcessMovedNode(c
|
|||
}
|
||||
|
||||
void DynamicPatriciaTrieNodeReader::invalidatePtNodeInfo() {
|
||||
mHeadPos = NOT_A_VALID_WORD_POS;
|
||||
mHeadPos = NOT_A_DICT_POS;
|
||||
mFlags = 0;
|
||||
mParentPos = NOT_A_DICT_POS;
|
||||
mCodePointCount = 0;
|
||||
|
@ -113,7 +113,7 @@ void DynamicPatriciaTrieNodeReader::invalidatePtNodeInfo() {
|
|||
mBigramLinkedNodePos = NOT_A_DICT_POS;
|
||||
mShortcutPos = NOT_A_DICT_POS;
|
||||
mBigramPos = NOT_A_DICT_POS;
|
||||
mSiblingPos = NOT_A_VALID_WORD_POS;
|
||||
mSiblingPos = NOT_A_DICT_POS;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -39,12 +39,12 @@ class DynamicPatriciaTrieNodeReader {
|
|||
const DictionaryBigramsStructurePolicy *const bigramsPolicy,
|
||||
const DictionaryShortcutsStructurePolicy *const shortcutsPolicy)
|
||||
: mBuffer(buffer), mBigramsPolicy(bigramsPolicy),
|
||||
mShortcutsPolicy(shortcutsPolicy), mHeadPos(NOT_A_VALID_WORD_POS), mFlags(0),
|
||||
mShortcutsPolicy(shortcutsPolicy), mHeadPos(NOT_A_DICT_POS), mFlags(0),
|
||||
mParentPos(NOT_A_DICT_POS), mCodePointCount(0), mProbabilityFieldPos(NOT_A_DICT_POS),
|
||||
mProbability(NOT_A_PROBABILITY), mChildrenPosFieldPos(NOT_A_DICT_POS),
|
||||
mChildrenPos(NOT_A_DICT_POS), mBigramLinkedNodePos(NOT_A_DICT_POS),
|
||||
mShortcutPos(NOT_A_DICT_POS), mBigramPos(NOT_A_DICT_POS),
|
||||
mSiblingPos(NOT_A_VALID_WORD_POS) {}
|
||||
mSiblingPos(NOT_A_DICT_POS) {}
|
||||
|
||||
~DynamicPatriciaTrieNodeReader() {}
|
||||
|
||||
|
@ -56,7 +56,7 @@ class DynamicPatriciaTrieNodeReader {
|
|||
|
||||
AK_FORCE_INLINE void fetchNodeInfoFromBufferAndGetNodeCodePoints(const int nodePos,
|
||||
const int maxCodePointCount, int *const outCodePoints) {
|
||||
mSiblingPos = NOT_A_VALID_WORD_POS;
|
||||
mSiblingPos = NOT_A_DICT_POS;
|
||||
mBigramLinkedNodePos = NOT_A_DICT_POS;
|
||||
fetchNodeInfoFromBufferAndProcessMovedNode(nodePos, maxCodePointCount, outCodePoints);
|
||||
}
|
||||
|
|
|
@ -116,7 +116,7 @@ int DynamicPatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const in
|
|||
if (!readingHelper.isMatchedCodePoint(
|
||||
j, searchCodePoints[matchedCodePointCount + j])) {
|
||||
// Different code point is found. The given word is not included in the dictionary.
|
||||
return NOT_A_VALID_WORD_POS;
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
}
|
||||
// All characters are matched.
|
||||
|
@ -125,14 +125,14 @@ int DynamicPatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const in
|
|||
return nodeReader->getHeadPos();
|
||||
}
|
||||
if (!nodeReader->hasChildren()) {
|
||||
return NOT_A_VALID_WORD_POS;
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
// Advance to the children nodes.
|
||||
readingHelper.readChildNode();
|
||||
}
|
||||
// If we already traversed the tree further than the word is long, there means
|
||||
// there was no match (or we would have found it).
|
||||
return NOT_A_VALID_WORD_POS;
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
|
||||
int DynamicPatriciaTriePolicy::getProbability(const int unigramProbability,
|
||||
|
@ -149,7 +149,7 @@ int DynamicPatriciaTriePolicy::getProbability(const int unigramProbability,
|
|||
}
|
||||
|
||||
int DynamicPatriciaTriePolicy::getUnigramProbabilityOfPtNode(const int nodePos) const {
|
||||
if (nodePos == NOT_A_VALID_WORD_POS) {
|
||||
if (nodePos == NOT_A_DICT_POS) {
|
||||
return NOT_A_PROBABILITY;
|
||||
}
|
||||
DynamicPatriciaTrieNodeReader nodeReader(&mBufferWithExtendableBuffer,
|
||||
|
@ -162,7 +162,7 @@ int DynamicPatriciaTriePolicy::getUnigramProbabilityOfPtNode(const int nodePos)
|
|||
}
|
||||
|
||||
int DynamicPatriciaTriePolicy::getShortcutPositionOfNode(const int nodePos) const {
|
||||
if (nodePos == NOT_A_VALID_WORD_POS) {
|
||||
if (nodePos == NOT_A_DICT_POS) {
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
DynamicPatriciaTrieNodeReader nodeReader(&mBufferWithExtendableBuffer,
|
||||
|
@ -175,7 +175,7 @@ int DynamicPatriciaTriePolicy::getShortcutPositionOfNode(const int nodePos) cons
|
|||
}
|
||||
|
||||
int DynamicPatriciaTriePolicy::getBigramsPositionOfNode(const int nodePos) const {
|
||||
if (nodePos == NOT_A_VALID_WORD_POS) {
|
||||
if (nodePos == NOT_A_DICT_POS) {
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
DynamicPatriciaTrieNodeReader nodeReader(&mBufferWithExtendableBuffer,
|
||||
|
@ -209,12 +209,12 @@ bool DynamicPatriciaTriePolicy::addBigramWords(const int *const word0, const int
|
|||
}
|
||||
const int word0Pos = getTerminalNodePositionOfWord(word0, length0,
|
||||
false /* forceLowerCaseSearch */);
|
||||
if (word0Pos == NOT_A_VALID_WORD_POS) {
|
||||
if (word0Pos == NOT_A_DICT_POS) {
|
||||
return false;
|
||||
}
|
||||
const int word1Pos = getTerminalNodePositionOfWord(word1, length1,
|
||||
false /* forceLowerCaseSearch */);
|
||||
if (word1Pos == NOT_A_VALID_WORD_POS) {
|
||||
if (word1Pos == NOT_A_DICT_POS) {
|
||||
return false;
|
||||
}
|
||||
DynamicPatriciaTrieWritingHelper writingHelper(&mBufferWithExtendableBuffer,
|
||||
|
@ -230,12 +230,12 @@ bool DynamicPatriciaTriePolicy::removeBigramWords(const int *const word0, const
|
|||
}
|
||||
const int word0Pos = getTerminalNodePositionOfWord(word0, length0,
|
||||
false /* forceLowerCaseSearch */);
|
||||
if (word0Pos == NOT_A_VALID_WORD_POS) {
|
||||
if (word0Pos == NOT_A_DICT_POS) {
|
||||
return false;
|
||||
}
|
||||
const int word1Pos = getTerminalNodePositionOfWord(word1, length1,
|
||||
false /* forceLowerCaseSearch */);
|
||||
if (word1Pos == NOT_A_VALID_WORD_POS) {
|
||||
if (word1Pos == NOT_A_DICT_POS) {
|
||||
return false;
|
||||
}
|
||||
DynamicPatriciaTrieWritingHelper writingHelper(&mBufferWithExtendableBuffer,
|
||||
|
|
|
@ -72,8 +72,7 @@ class DynamicPatriciaTrieReadingHelper {
|
|||
|
||||
// Initialize reading state with the head position of a node.
|
||||
AK_FORCE_INLINE void initWithNodePos(const int nodePos) {
|
||||
// TODO: Consolidate NOT_A_VALID_WORD_POS and NOT_A_DICT_POS
|
||||
if (nodePos == NOT_A_VALID_WORD_POS || nodePos == NOT_A_DICT_POS) {
|
||||
if (nodePos == NOT_A_DICT_POS) {
|
||||
mPos = NOT_A_DICT_POS;
|
||||
} else {
|
||||
mIsError = false;
|
||||
|
|
|
@ -219,7 +219,7 @@ int PatriciaTriePolicy::getCodePointsAndProbabilityAndReturnCodePointCount(
|
|||
}
|
||||
|
||||
// This function gets the position of the terminal node of the exact matching word in the
|
||||
// dictionary. If no match is found, it returns NOT_A_VALID_WORD_POS.
|
||||
// dictionary. If no match is found, it returns NOT_A_DICT_POS.
|
||||
int PatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const inWord,
|
||||
const int length, const bool forceLowerCaseSearch) const {
|
||||
int pos = getRootPosition();
|
||||
|
@ -228,7 +228,7 @@ int PatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const inWord,
|
|||
while (true) {
|
||||
// If we already traversed the tree further than the word is long, there means
|
||||
// there was no match (or we would have found it).
|
||||
if (wordPos >= length) return NOT_A_VALID_WORD_POS;
|
||||
if (wordPos >= length) return NOT_A_DICT_POS;
|
||||
int ptNodeCount = PatriciaTrieReadingUtils::getPtNodeArraySizeAndAdvancePosition(mDictRoot,
|
||||
&pos);
|
||||
const int wChar = forceLowerCaseSearch
|
||||
|
@ -236,7 +236,7 @@ int PatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const inWord,
|
|||
while (true) {
|
||||
// If there are no more PtNodes in this array, it means we could not
|
||||
// find a matching character for this depth, therefore there is no match.
|
||||
if (0 >= ptNodeCount) return NOT_A_VALID_WORD_POS;
|
||||
if (0 >= ptNodeCount) return NOT_A_DICT_POS;
|
||||
const int ptNodePos = pos;
|
||||
const PatriciaTrieReadingUtils::NodeFlags flags =
|
||||
PatriciaTrieReadingUtils::getFlagsAndAdvancePosition(mDictRoot, &pos);
|
||||
|
@ -245,7 +245,7 @@ int PatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const inWord,
|
|||
if (character == wChar) {
|
||||
// This is the correct PtNode. Only one PtNode may start with the same char within
|
||||
// a PtNode array, so either we found our match in this array, or there is
|
||||
// no match and we can return NOT_A_VALID_WORD_POS. So we will check all the
|
||||
// no match and we can return NOT_A_DICT_POS. So we will check all the
|
||||
// characters in this PtNode indeed does match.
|
||||
if (PatriciaTrieReadingUtils::hasMultipleChars(flags)) {
|
||||
character = PatriciaTrieReadingUtils::getCodePointAndAdvancePosition(mDictRoot,
|
||||
|
@ -256,8 +256,8 @@ int PatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const inWord,
|
|||
// character that does not match, as explained above, it means the word is
|
||||
// not in the dictionary (by virtue of this PtNode being the only one to
|
||||
// match the word on the first character, but not matching the whole word).
|
||||
if (wordPos >= length) return NOT_A_VALID_WORD_POS;
|
||||
if (inWord[wordPos] != character) return NOT_A_VALID_WORD_POS;
|
||||
if (wordPos >= length) return NOT_A_DICT_POS;
|
||||
if (inWord[wordPos] != character) return NOT_A_DICT_POS;
|
||||
character = PatriciaTrieReadingUtils::getCodePointAndAdvancePosition(
|
||||
mDictRoot, &pos);
|
||||
}
|
||||
|
@ -274,7 +274,7 @@ int PatriciaTriePolicy::getTerminalNodePositionOfWord(const int *const inWord,
|
|||
PatriciaTrieReadingUtils::readProbabilityAndAdvancePosition(mDictRoot, &pos);
|
||||
}
|
||||
if (!PatriciaTrieReadingUtils::hasChildrenInFlags(flags)) {
|
||||
return NOT_A_VALID_WORD_POS;
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
// We have children and we are still shorter than the word we are searching for, so
|
||||
// we need to traverse children. Put the pointer on the children position, and
|
||||
|
@ -320,7 +320,7 @@ int PatriciaTriePolicy::getProbability(const int unigramProbability,
|
|||
}
|
||||
|
||||
int PatriciaTriePolicy::getUnigramProbabilityOfPtNode(const int nodePos) const {
|
||||
if (nodePos == NOT_A_VALID_WORD_POS) {
|
||||
if (nodePos == NOT_A_DICT_POS) {
|
||||
return NOT_A_PROBABILITY;
|
||||
}
|
||||
int pos = nodePos;
|
||||
|
@ -342,7 +342,7 @@ int PatriciaTriePolicy::getUnigramProbabilityOfPtNode(const int nodePos) const {
|
|||
}
|
||||
|
||||
int PatriciaTriePolicy::getShortcutPositionOfNode(const int nodePos) const {
|
||||
if (nodePos == NOT_A_VALID_WORD_POS) {
|
||||
if (nodePos == NOT_A_DICT_POS) {
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
int pos = nodePos;
|
||||
|
@ -362,7 +362,7 @@ int PatriciaTriePolicy::getShortcutPositionOfNode(const int nodePos) const {
|
|||
}
|
||||
|
||||
int PatriciaTriePolicy::getBigramsPositionOfNode(const int nodePos) const {
|
||||
if (nodePos == NOT_A_VALID_WORD_POS) {
|
||||
if (nodePos == NOT_A_DICT_POS) {
|
||||
return NOT_A_DICT_POS;
|
||||
}
|
||||
int pos = nodePos;
|
||||
|
|
Loading…
Reference in New Issue