1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef LATINIME_DIC_NODE_PROPERTIES_H 18 #define LATINIME_DIC_NODE_PROPERTIES_H 19 20 #include <stdint.h> 21 22 #include "binary_format.h" 23 #include "defines.h" 24 25 namespace latinime { 26 27 /** 28 * Node for traversing the lexicon trie. 29 */ 30 class DicNodeProperties { 31 public: 32 AK_FORCE_INLINE DicNodeProperties() 33 : mPos(0), mFlags(0), mChildrenPos(0), mAttributesPos(0), mSiblingPos(0), 34 mChildrenCount(0), mProbability(0), mBigramProbability(0), mNodeCodePoint(0), 35 mDepth(0), mLeavingDepth(0), mIsTerminal(false), mHasMultipleChars(false), 36 mHasChildren(false) { 37 } 38 39 virtual ~DicNodeProperties() {} 40 41 // Should be called only once per DicNode is initialized. 42 void init(const int pos, const uint8_t flags, const int childrenPos, const int attributesPos, 43 const int siblingPos, const int nodeCodePoint, const int childrenCount, 44 const int probability, const int bigramProbability, const bool isTerminal, 45 const bool hasMultipleChars, const bool hasChildren, const uint16_t depth, 46 const uint16_t terminalDepth) { 47 mPos = pos; 48 mFlags = flags; 49 mChildrenPos = childrenPos; 50 mAttributesPos = attributesPos; 51 mSiblingPos = siblingPos; 52 mNodeCodePoint = nodeCodePoint; 53 mChildrenCount = childrenCount; 54 mProbability = probability; 55 mBigramProbability = bigramProbability; 56 mIsTerminal = isTerminal; 57 mHasMultipleChars = hasMultipleChars; 58 mHasChildren = hasChildren; 59 mDepth = depth; 60 mLeavingDepth = terminalDepth; 61 } 62 63 // Init for copy 64 void init(const DicNodeProperties *const nodeProp) { 65 mPos = nodeProp->mPos; 66 mFlags = nodeProp->mFlags; 67 mChildrenPos = nodeProp->mChildrenPos; 68 mAttributesPos = nodeProp->mAttributesPos; 69 mSiblingPos = nodeProp->mSiblingPos; 70 mNodeCodePoint = nodeProp->mNodeCodePoint; 71 mChildrenCount = nodeProp->mChildrenCount; 72 mProbability = nodeProp->mProbability; 73 mBigramProbability = nodeProp->mBigramProbability; 74 mIsTerminal = nodeProp->mIsTerminal; 75 mHasMultipleChars = nodeProp->mHasMultipleChars; 76 mHasChildren = nodeProp->mHasChildren; 77 mDepth = nodeProp->mDepth; 78 mLeavingDepth = nodeProp->mLeavingDepth; 79 } 80 81 // Init as passing child 82 void init(const DicNodeProperties *const nodeProp, const int codePoint) { 83 mPos = nodeProp->mPos; 84 mFlags = nodeProp->mFlags; 85 mChildrenPos = nodeProp->mChildrenPos; 86 mAttributesPos = nodeProp->mAttributesPos; 87 mSiblingPos = nodeProp->mSiblingPos; 88 mNodeCodePoint = codePoint; // Overwrite the node char of a passing child 89 mChildrenCount = nodeProp->mChildrenCount; 90 mProbability = nodeProp->mProbability; 91 mBigramProbability = nodeProp->mBigramProbability; 92 mIsTerminal = nodeProp->mIsTerminal; 93 mHasMultipleChars = nodeProp->mHasMultipleChars; 94 mHasChildren = nodeProp->mHasChildren; 95 mDepth = nodeProp->mDepth + 1; // Increment the depth of a passing child 96 mLeavingDepth = nodeProp->mLeavingDepth; 97 } 98 99 int getPos() const { 100 return mPos; 101 } 102 103 uint8_t getFlags() const { 104 return mFlags; 105 } 106 107 int getChildrenPos() const { 108 return mChildrenPos; 109 } 110 111 int getAttributesPos() const { 112 return mAttributesPos; 113 } 114 115 int getChildrenCount() const { 116 return mChildrenCount; 117 } 118 119 int getProbability() const { 120 return mProbability; 121 } 122 123 int getNodeCodePoint() const { 124 return mNodeCodePoint; 125 } 126 127 uint16_t getDepth() const { 128 return mDepth; 129 } 130 131 // TODO: Move to output? 132 uint16_t getLeavingDepth() const { 133 return mLeavingDepth; 134 } 135 136 bool isTerminal() const { 137 return mIsTerminal; 138 } 139 140 bool hasMultipleChars() const { 141 return mHasMultipleChars; 142 } 143 144 bool hasChildren() const { 145 return mChildrenCount > 0 || mDepth != mLeavingDepth; 146 } 147 148 bool hasBlacklistedOrNotAWordFlag() const { 149 return BinaryFormat::hasBlacklistedOrNotAWordFlag(mFlags); 150 } 151 152 private: 153 // Caution!!! 154 // Use a default copy constructor and an assign operator because shallow copies are ok 155 // for this class 156 157 // Not used 158 int getSiblingPos() const { 159 return mSiblingPos; 160 } 161 162 int mPos; 163 uint8_t mFlags; 164 int mChildrenPos; 165 int mAttributesPos; 166 int mSiblingPos; 167 int mChildrenCount; 168 int mProbability; 169 int mBigramProbability; // not used for now 170 int mNodeCodePoint; 171 uint16_t mDepth; 172 uint16_t mLeavingDepth; 173 bool mIsTerminal; 174 bool mHasMultipleChars; 175 bool mHasChildren; 176 }; 177 } // namespace latinime 178 #endif // LATINIME_DIC_NODE_PROPERTIES_H 179