Add spellcheck and word suggestion to the prediction service

third_party/prediction/suggest/policyimpl/dictionary/structure/pt_common/pt_node_params.h

Index: third_party/prediction/suggest/policyimpl/dictionary/structure/pt_common/pt_node_params.h
diff --git a/third_party/prediction/suggest/policyimpl/dictionary/structure/pt_common/pt_node_params.h b/third_party/prediction/suggest/policyimpl/dictionary/structure/pt_common/pt_node_params.h
new file mode 100644
index 0000000000000000000000000000000000000000..c41e437edd87aa6387b94ddc356adbb1d810932b
--- /dev/null
+++ b/third_party/prediction/suggest/policyimpl/dictionary/structure/pt_common/pt_node_params.h
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2013, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LATINIME_PT_NODE_PARAMS_H
+#define LATINIME_PT_NODE_PARAMS_H
+
+#include <cstring>
+
+#include "third_party/prediction/defines.h"
+#include "third_party/prediction/suggest/policyimpl/dictionary/structure/pt_common/dynamic_pt_reading_utils.h"
+#include "third_party/prediction/suggest/policyimpl/dictionary/structure/pt_common/patricia_trie_reading_utils.h"
+#include "third_party/prediction/suggest/policyimpl/dictionary/structure/v4/ver4_dict_constants.h"
+#include "third_party/prediction/utils/char_utils.h"
+
+namespace latinime {
+
+// This class has information of a PtNode. This class is immutable.
+class PtNodeParams {
+ public:
+  // Invalid PtNode.
+  PtNodeParams()
+      : mHeadPos(NOT_A_DICT_POS),
+        mFlags(0),
+        mHasMovedFlag(false),
+        mParentPos(NOT_A_DICT_POS),
+        mCodePointCount(0),
+        mCodePoints(),
+        mTerminalIdFieldPos(NOT_A_DICT_POS),
+        mTerminalId(Ver4DictConstants::NOT_A_TERMINAL_ID),
+        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_DICT_POS) {}
+
+  PtNodeParams(const PtNodeParams& ptNodeParams)
+      : mHeadPos(ptNodeParams.mHeadPos),
+        mFlags(ptNodeParams.mFlags),
+        mHasMovedFlag(ptNodeParams.mHasMovedFlag),
+        mParentPos(ptNodeParams.mParentPos),
+        mCodePointCount(ptNodeParams.mCodePointCount),
+        mCodePoints(),
+        mTerminalIdFieldPos(ptNodeParams.mTerminalIdFieldPos),
+        mTerminalId(ptNodeParams.mTerminalId),
+        mProbabilityFieldPos(ptNodeParams.mProbabilityFieldPos),
+        mProbability(ptNodeParams.mProbability),
+        mChildrenPosFieldPos(ptNodeParams.mChildrenPosFieldPos),
+        mChildrenPos(ptNodeParams.mChildrenPos),
+        mBigramLinkedNodePos(ptNodeParams.mBigramLinkedNodePos),
+        mShortcutPos(ptNodeParams.mShortcutPos),
+        mBigramPos(ptNodeParams.mBigramPos),
+        mSiblingPos(ptNodeParams.mSiblingPos) {
+    memcpy(mCodePoints, ptNodeParams.getCodePoints(),
+           sizeof(int) * mCodePointCount);
+  }
+
+  // PtNode read from version 2 dictionary.
+  PtNodeParams(const int headPos,
+               const PatriciaTrieReadingUtils::NodeFlags flags,
+               const int codePointCount,
+               const int* const codePoints,
+               const int probability,
+               const int childrenPos,
+               const int shortcutPos,
+               const int bigramPos,
+               const int siblingPos)
+      : mHeadPos(headPos),
+        mFlags(flags),
+        mHasMovedFlag(false),
+        mParentPos(NOT_A_DICT_POS),
+        mCodePointCount(codePointCount),
+        mCodePoints(),
+        mTerminalIdFieldPos(NOT_A_DICT_POS),
+        mTerminalId(Ver4DictConstants::NOT_A_TERMINAL_ID),
+        mProbabilityFieldPos(NOT_A_DICT_POS),
+        mProbability(probability),
+        mChildrenPosFieldPos(NOT_A_DICT_POS),
+        mChildrenPos(childrenPos),
+        mBigramLinkedNodePos(NOT_A_DICT_POS),
+        mShortcutPos(shortcutPos),
+        mBigramPos(bigramPos),
+        mSiblingPos(siblingPos) {
+    memcpy(mCodePoints, codePoints, sizeof(int) * mCodePointCount);
+  }
+
+  // PtNode with a terminal id.
+  PtNodeParams(const int headPos,
+               const PatriciaTrieReadingUtils::NodeFlags flags,
+               const int parentPos,
+               const int codePointCount,
+               const int* const codePoints,
+               const int terminalIdFieldPos,
+               const int terminalId,
+               const int probability,
+               const int childrenPosFieldPos,
+               const int childrenPos,
+               const int siblingPos)
+      : mHeadPos(headPos),
+        mFlags(flags),
+        mHasMovedFlag(true),
+        mParentPos(parentPos),
+        mCodePointCount(codePointCount),
+        mCodePoints(),
+        mTerminalIdFieldPos(terminalIdFieldPos),
+        mTerminalId(terminalId),
+        mProbabilityFieldPos(NOT_A_DICT_POS),
+        mProbability(probability),
+        mChildrenPosFieldPos(childrenPosFieldPos),
+        mChildrenPos(childrenPos),
+        mBigramLinkedNodePos(NOT_A_DICT_POS),
+        mShortcutPos(terminalId),
+        mBigramPos(terminalId),
+        mSiblingPos(siblingPos) {
+    memcpy(mCodePoints, codePoints, sizeof(int) * mCodePointCount);
+  }
+
+  // Construct new params by updating existing PtNode params.
+  PtNodeParams(const PtNodeParams* const ptNodeParams,
+               const PatriciaTrieReadingUtils::NodeFlags flags,
+               const int parentPos,
+               const int codePointCount,
+               const int* const codePoints,
+               const int probability)
+      : mHeadPos(ptNodeParams->getHeadPos()),
+        mFlags(flags),
+        mHasMovedFlag(true),
+        mParentPos(parentPos),
+        mCodePointCount(codePointCount),
+        mCodePoints(),
+        mTerminalIdFieldPos(ptNodeParams->getTerminalIdFieldPos()),
+        mTerminalId(ptNodeParams->getTerminalId()),
+        mProbabilityFieldPos(ptNodeParams->getProbabilityFieldPos()),
+        mProbability(probability),
+        mChildrenPosFieldPos(ptNodeParams->getChildrenPosFieldPos()),
+        mChildrenPos(ptNodeParams->getChildrenPos()),
+        mBigramLinkedNodePos(ptNodeParams->getBigramLinkedNodePos()),
+        mShortcutPos(ptNodeParams->getShortcutPos()),
+        mBigramPos(ptNodeParams->getBigramsPos()),
+        mSiblingPos(ptNodeParams->getSiblingNodePos()) {
+    memcpy(mCodePoints, codePoints, sizeof(int) * mCodePointCount);
+  }
+
+  PtNodeParams(const PatriciaTrieReadingUtils::NodeFlags flags,
+               const int parentPos,
+               const int codePointCount,
+               const int* const codePoints,
+               const int probability)
+      : mHeadPos(NOT_A_DICT_POS),
+        mFlags(flags),
+        mHasMovedFlag(true),
+        mParentPos(parentPos),
+        mCodePointCount(codePointCount),
+        mCodePoints(),
+        mTerminalIdFieldPos(NOT_A_DICT_POS),
+        mTerminalId(Ver4DictConstants::NOT_A_TERMINAL_ID),
+        mProbabilityFieldPos(NOT_A_DICT_POS),
+        mProbability(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_DICT_POS) {
+    memcpy(mCodePoints, codePoints, sizeof(int) * mCodePointCount);
+  }
+
+  AK_FORCE_INLINE bool isValid() const { return mCodePointCount > 0; }
+
+  // Head position of the PtNode
+  AK_FORCE_INLINE int getHeadPos() const { return mHeadPos; }
+
+  // Flags
+  AK_FORCE_INLINE bool isDeleted() const {
+    return mHasMovedFlag && DynamicPtReadingUtils::isDeleted(mFlags);
+  }
+
+  AK_FORCE_INLINE bool willBecomeNonTerminal() const {
+    return mHasMovedFlag &&
+           DynamicPtReadingUtils::willBecomeNonTerminal(mFlags);
+  }
+
+  AK_FORCE_INLINE bool hasChildren() const {
+    return mChildrenPos != NOT_A_DICT_POS;
+  }
+
+  AK_FORCE_INLINE bool isTerminal() const {
+    return PatriciaTrieReadingUtils::isTerminal(mFlags);
+  }
+
+  AK_FORCE_INLINE bool isBlacklisted() const {
+    return PatriciaTrieReadingUtils::isBlacklisted(mFlags);
+  }
+
+  AK_FORCE_INLINE bool isNotAWord() const {
+    return PatriciaTrieReadingUtils::isNotAWord(mFlags);
+  }
+
+  AK_FORCE_INLINE bool hasBigrams() const {
+    return PatriciaTrieReadingUtils::hasBigrams(mFlags);
+  }
+
+  AK_FORCE_INLINE bool hasShortcutTargets() const {
+    return PatriciaTrieReadingUtils::hasShortcutTargets(mFlags);
+  }
+
+  AK_FORCE_INLINE bool representsNonWordInfo() const {
+    return getCodePointCount() > 0 &&
+           !CharUtils::isInUnicodeSpace(getCodePoints()[0]) && isNotAWord();
+  }
+
+  AK_FORCE_INLINE int representsBeginningOfSentence() const {
+    return getCodePointCount() > 0 &&
+           getCodePoints()[0] == CODE_POINT_BEGINNING_OF_SENTENCE &&
+           isNotAWord();
+  }
+
+  // Parent node position
+  AK_FORCE_INLINE int getParentPos() const { return mParentPos; }
+
+  // Number of code points
+  AK_FORCE_INLINE uint8_t getCodePointCount() const { return mCodePointCount; }
+
+  AK_FORCE_INLINE const int* getCodePoints() const { return mCodePoints; }
+
+  // Probability
+  AK_FORCE_INLINE int getTerminalIdFieldPos() const {
+    return mTerminalIdFieldPos;
+  }
+
+  AK_FORCE_INLINE int getTerminalId() const { return mTerminalId; }
+
+  // Probability
+  AK_FORCE_INLINE int getProbabilityFieldPos() const {
+    return mProbabilityFieldPos;
+  }
+
+  AK_FORCE_INLINE int getProbability() const { return mProbability; }
+
+  // Children PtNode array position
+  AK_FORCE_INLINE int getChildrenPosFieldPos() const {
+    return mChildrenPosFieldPos;
+  }
+
+  AK_FORCE_INLINE int getChildrenPos() const { return mChildrenPos; }
+
+  // Bigram linked node position.
+  AK_FORCE_INLINE int getBigramLinkedNodePos() const {
+    return mBigramLinkedNodePos;
+  }
+
+  // Shortcutlist position
+  AK_FORCE_INLINE int getShortcutPos() const { return mShortcutPos; }
+
+  // Bigrams position
+  AK_FORCE_INLINE int getBigramsPos() const { return mBigramPos; }
+
+  // Sibling node position
+  AK_FORCE_INLINE int getSiblingNodePos() const { return mSiblingPos; }
+
+ private:
+  // This class have a public copy constructor to be used as a return value.
+  DISALLOW_ASSIGNMENT_OPERATOR(PtNodeParams);
+
+  const int mHeadPos;
+  const PatriciaTrieReadingUtils::NodeFlags mFlags;
+  const bool mHasMovedFlag;
+  const int mParentPos;
+  const uint8_t mCodePointCount;
+  int mCodePoints[MAX_WORD_LENGTH];
+  const int mTerminalIdFieldPos;
+  const int mTerminalId;
+  const int mProbabilityFieldPos;
+  const int mProbability;
+  const int mChildrenPosFieldPos;
+  const int mChildrenPos;
+  const int mBigramLinkedNodePos;
+  const int mShortcutPos;
+  const int mBigramPos;
+  const int mSiblingPos;
+};
+}  // namespace latinime
+#endif /* LATINIME_PT_NODE_PARAMS_H */