Home | History | Annotate | Download | only in v402
      1 /*
      2  * Copyright (C) 2013, 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 /*
     18  * !!!!! DO NOT EDIT THIS FILE !!!!!
     19  *
     20  * This file was generated from
     21  *   dictionary/structure/v4/ver4_patricia_trie_node_writer.cpp
     22  */
     23 
     24 #include "dictionary/structure/backward/v402/ver4_patricia_trie_node_writer.h"
     25 
     26 #include "dictionary/header/header_policy.h"
     27 #include "dictionary/property/unigram_property.h"
     28 #include "dictionary/structure/pt_common/dynamic_pt_reading_utils.h"
     29 #include "dictionary/structure/pt_common/dynamic_pt_writing_utils.h"
     30 #include "dictionary/structure/pt_common/patricia_trie_reading_utils.h"
     31 #include "dictionary/structure/backward/v402/bigram/ver4_bigram_list_policy.h"
     32 #include "dictionary/structure/backward/v402/content/probability_entry.h"
     33 #include "dictionary/structure/backward/v402/shortcut/ver4_shortcut_list_policy.h"
     34 #include "dictionary/structure/backward/v402/ver4_patricia_trie_node_reader.h"
     35 #include "dictionary/structure/backward/v402/ver4_dict_buffers.h"
     36 #include "dictionary/utils/buffer_with_extendable_buffer.h"
     37 #include "dictionary/utils/forgetting_curve_utils.h"
     38 
     39 namespace latinime {
     40 namespace backward {
     41 namespace v402 {
     42 
     43 const int Ver4PatriciaTrieNodeWriter::CHILDREN_POSITION_FIELD_SIZE = 3;
     44 
     45 bool Ver4PatriciaTrieNodeWriter::markPtNodeAsDeleted(
     46         const PtNodeParams *const toBeUpdatedPtNodeParams) {
     47     int pos = toBeUpdatedPtNodeParams->getHeadPos();
     48     const bool usesAdditionalBuffer = mTrieBuffer->isInAdditionalBuffer(pos);
     49     const uint8_t *const dictBuf = mTrieBuffer->getBuffer(usesAdditionalBuffer);
     50     if (usesAdditionalBuffer) {
     51         pos -= mTrieBuffer->getOriginalBufferSize();
     52     }
     53     // Read original flags
     54     const PatriciaTrieReadingUtils::NodeFlags originalFlags =
     55             PatriciaTrieReadingUtils::getFlagsAndAdvancePosition(dictBuf, &pos);
     56     const PatriciaTrieReadingUtils::NodeFlags updatedFlags =
     57             DynamicPtReadingUtils::updateAndGetFlags(originalFlags, false /* isMoved */,
     58                     true /* isDeleted */, false /* willBecomeNonTerminal */);
     59     int writingPos = toBeUpdatedPtNodeParams->getHeadPos();
     60     // Update flags.
     61     if (!DynamicPtWritingUtils::writeFlagsAndAdvancePosition(mTrieBuffer, updatedFlags,
     62             &writingPos)) {
     63         return false;
     64     }
     65     if (toBeUpdatedPtNodeParams->isTerminal()) {
     66         // The PtNode is a terminal. Delete entry from the terminal position lookup table.
     67         return mBuffers->getMutableTerminalPositionLookupTable()->setTerminalPtNodePosition(
     68                 toBeUpdatedPtNodeParams->getTerminalId(), NOT_A_DICT_POS /* ptNodePos */);
     69     } else {
     70         return true;
     71     }
     72 }
     73 
     74 bool Ver4PatriciaTrieNodeWriter::markPtNodeAsMoved(
     75         const PtNodeParams *const toBeUpdatedPtNodeParams,
     76         const int movedPos, const int bigramLinkedNodePos) {
     77     int pos = toBeUpdatedPtNodeParams->getHeadPos();
     78     const bool usesAdditionalBuffer = mTrieBuffer->isInAdditionalBuffer(pos);
     79     const uint8_t *const dictBuf = mTrieBuffer->getBuffer(usesAdditionalBuffer);
     80     if (usesAdditionalBuffer) {
     81         pos -= mTrieBuffer->getOriginalBufferSize();
     82     }
     83     // Read original flags
     84     const PatriciaTrieReadingUtils::NodeFlags originalFlags =
     85             PatriciaTrieReadingUtils::getFlagsAndAdvancePosition(dictBuf, &pos);
     86     const PatriciaTrieReadingUtils::NodeFlags updatedFlags =
     87             DynamicPtReadingUtils::updateAndGetFlags(originalFlags, true /* isMoved */,
     88                     false /* isDeleted */, false /* willBecomeNonTerminal */);
     89     int writingPos = toBeUpdatedPtNodeParams->getHeadPos();
     90     // Update flags.
     91     if (!DynamicPtWritingUtils::writeFlagsAndAdvancePosition(mTrieBuffer, updatedFlags,
     92             &writingPos)) {
     93         return false;
     94     }
     95     // Update moved position, which is stored in the parent offset field.
     96     if (!DynamicPtWritingUtils::writeParentPosOffsetAndAdvancePosition(
     97             mTrieBuffer, movedPos, toBeUpdatedPtNodeParams->getHeadPos(), &writingPos)) {
     98         return false;
     99     }
    100     if (toBeUpdatedPtNodeParams->hasChildren()) {
    101         // Update children's parent position.
    102         mReadingHelper.initWithPtNodeArrayPos(toBeUpdatedPtNodeParams->getChildrenPos());
    103         while (!mReadingHelper.isEnd()) {
    104             const PtNodeParams childPtNodeParams(mReadingHelper.getPtNodeParams());
    105             int parentOffsetFieldPos = childPtNodeParams.getHeadPos()
    106                     + DynamicPtWritingUtils::NODE_FLAG_FIELD_SIZE;
    107             if (!DynamicPtWritingUtils::writeParentPosOffsetAndAdvancePosition(
    108                     mTrieBuffer, bigramLinkedNodePos, childPtNodeParams.getHeadPos(),
    109                     &parentOffsetFieldPos)) {
    110                 // Parent offset cannot be written because of a bug or a broken dictionary; thus,
    111                 // we give up to update dictionary.
    112                 return false;
    113             }
    114             mReadingHelper.readNextSiblingNode(childPtNodeParams);
    115         }
    116     }
    117     return true;
    118 }
    119 
    120 bool Ver4PatriciaTrieNodeWriter::markPtNodeAsWillBecomeNonTerminal(
    121         const PtNodeParams *const toBeUpdatedPtNodeParams) {
    122     int pos = toBeUpdatedPtNodeParams->getHeadPos();
    123     const bool usesAdditionalBuffer = mTrieBuffer->isInAdditionalBuffer(pos);
    124     const uint8_t *const dictBuf = mTrieBuffer->getBuffer(usesAdditionalBuffer);
    125     if (usesAdditionalBuffer) {
    126         pos -= mTrieBuffer->getOriginalBufferSize();
    127     }
    128     // Read original flags
    129     const PatriciaTrieReadingUtils::NodeFlags originalFlags =
    130             PatriciaTrieReadingUtils::getFlagsAndAdvancePosition(dictBuf, &pos);
    131     const PatriciaTrieReadingUtils::NodeFlags updatedFlags =
    132             DynamicPtReadingUtils::updateAndGetFlags(originalFlags, false /* isMoved */,
    133                     false /* isDeleted */, true /* willBecomeNonTerminal */);
    134     if (!mBuffers->getMutableTerminalPositionLookupTable()->setTerminalPtNodePosition(
    135             toBeUpdatedPtNodeParams->getTerminalId(), NOT_A_DICT_POS /* ptNodePos */)) {
    136         AKLOGE("Cannot update terminal position lookup table. terminal id: %d",
    137                 toBeUpdatedPtNodeParams->getTerminalId());
    138         return false;
    139     }
    140     // Update flags.
    141     int writingPos = toBeUpdatedPtNodeParams->getHeadPos();
    142     return DynamicPtWritingUtils::writeFlagsAndAdvancePosition(mTrieBuffer, updatedFlags,
    143             &writingPos);
    144 }
    145 
    146 bool Ver4PatriciaTrieNodeWriter::updatePtNodeUnigramProperty(
    147         const PtNodeParams *const toBeUpdatedPtNodeParams,
    148         const UnigramProperty *const unigramProperty) {
    149     // Update probability and historical information.
    150     // TODO: Update other information in the unigram property.
    151     if (!toBeUpdatedPtNodeParams->isTerminal()) {
    152         return false;
    153     }
    154     const ProbabilityEntry originalProbabilityEntry =
    155             mBuffers->getProbabilityDictContent()->getProbabilityEntry(
    156                     toBeUpdatedPtNodeParams->getTerminalId());
    157     const ProbabilityEntry probabilityEntry = createUpdatedEntryFrom(&originalProbabilityEntry,
    158             unigramProperty);
    159     return mBuffers->getMutableProbabilityDictContent()->setProbabilityEntry(
    160             toBeUpdatedPtNodeParams->getTerminalId(), &probabilityEntry);
    161 }
    162 
    163 bool Ver4PatriciaTrieNodeWriter::updatePtNodeProbabilityAndGetNeedsToKeepPtNodeAfterGC(
    164         const PtNodeParams *const toBeUpdatedPtNodeParams, bool *const outNeedsToKeepPtNode) {
    165     if (!toBeUpdatedPtNodeParams->isTerminal()) {
    166         AKLOGE("updatePtNodeProbabilityAndGetNeedsToSaveForGC is called for non-terminal PtNode.");
    167         return false;
    168     }
    169     const ProbabilityEntry originalProbabilityEntry =
    170             mBuffers->getProbabilityDictContent()->getProbabilityEntry(
    171                     toBeUpdatedPtNodeParams->getTerminalId());
    172     if (originalProbabilityEntry.hasHistoricalInfo()) {
    173         const HistoricalInfo historicalInfo = ForgettingCurveUtils::createHistoricalInfoToSave(
    174                 originalProbabilityEntry.getHistoricalInfo(), mHeaderPolicy);
    175         const ProbabilityEntry probabilityEntry =
    176                 originalProbabilityEntry.createEntryWithUpdatedHistoricalInfo(&historicalInfo);
    177         if (!mBuffers->getMutableProbabilityDictContent()->setProbabilityEntry(
    178                 toBeUpdatedPtNodeParams->getTerminalId(), &probabilityEntry)) {
    179             AKLOGE("Cannot write updated probability entry. terminalId: %d",
    180                     toBeUpdatedPtNodeParams->getTerminalId());
    181             return false;
    182         }
    183         const bool isValid = ForgettingCurveUtils::needsToKeep(&historicalInfo, mHeaderPolicy);
    184         if (!isValid) {
    185             if (!markPtNodeAsWillBecomeNonTerminal(toBeUpdatedPtNodeParams)) {
    186                 AKLOGE("Cannot mark PtNode as willBecomeNonTerminal.");
    187                 return false;
    188             }
    189         }
    190         *outNeedsToKeepPtNode = isValid;
    191     } else {
    192         // No need to update probability.
    193         *outNeedsToKeepPtNode = true;
    194     }
    195     return true;
    196 }
    197 
    198 bool Ver4PatriciaTrieNodeWriter::updateChildrenPosition(
    199         const PtNodeParams *const toBeUpdatedPtNodeParams, const int newChildrenPosition) {
    200     int childrenPosFieldPos = toBeUpdatedPtNodeParams->getChildrenPosFieldPos();
    201     return DynamicPtWritingUtils::writeChildrenPositionAndAdvancePosition(mTrieBuffer,
    202             newChildrenPosition, &childrenPosFieldPos);
    203 }
    204 
    205 bool Ver4PatriciaTrieNodeWriter::updateTerminalId(const PtNodeParams *const toBeUpdatedPtNodeParams,
    206         const int newTerminalId) {
    207     return mTrieBuffer->writeUint(newTerminalId, Ver4DictConstants::TERMINAL_ID_FIELD_SIZE,
    208             toBeUpdatedPtNodeParams->getTerminalIdFieldPos());
    209 }
    210 
    211 bool Ver4PatriciaTrieNodeWriter::writePtNodeAndAdvancePosition(
    212         const PtNodeParams *const ptNodeParams, int *const ptNodeWritingPos) {
    213     return writePtNodeAndGetTerminalIdAndAdvancePosition(ptNodeParams, 0 /* outTerminalId */,
    214             ptNodeWritingPos);
    215 }
    216 
    217 
    218 bool Ver4PatriciaTrieNodeWriter::writeNewTerminalPtNodeAndAdvancePosition(
    219         const PtNodeParams *const ptNodeParams, const UnigramProperty *const unigramProperty,
    220         int *const ptNodeWritingPos) {
    221     int terminalId = Ver4DictConstants::NOT_A_TERMINAL_ID;
    222     if (!writePtNodeAndGetTerminalIdAndAdvancePosition(ptNodeParams, &terminalId,
    223             ptNodeWritingPos)) {
    224         return false;
    225     }
    226     // Write probability.
    227     ProbabilityEntry newProbabilityEntry;
    228     const ProbabilityEntry probabilityEntryToWrite = createUpdatedEntryFrom(
    229             &newProbabilityEntry, unigramProperty);
    230     return mBuffers->getMutableProbabilityDictContent()->setProbabilityEntry(terminalId,
    231             &probabilityEntryToWrite);
    232 }
    233 
    234 bool Ver4PatriciaTrieNodeWriter::addNgramEntry(const WordIdArrayView prevWordIds, const int wordId,
    235         const NgramProperty *const ngramProperty, bool *const outAddedNewEntry) {
    236     if (!mBigramPolicy->addNewEntry(prevWordIds[0], wordId, ngramProperty, outAddedNewEntry)) {
    237         AKLOGE("Cannot add new bigram entry. prevWordId: %d, wordId: %d",
    238                 prevWordIds[0], wordId);
    239         return false;
    240     }
    241     const int ptNodePos =
    242             mBuffers->getTerminalPositionLookupTable()->getTerminalPtNodePosition(prevWordIds[0]);
    243     const PtNodeParams sourcePtNodeParams =
    244             mPtNodeReader->fetchPtNodeParamsInBufferFromPtNodePos(ptNodePos);
    245     if (!sourcePtNodeParams.hasBigrams()) {
    246         // Update has bigrams flag.
    247         return updatePtNodeFlags(sourcePtNodeParams.getHeadPos(),
    248                 sourcePtNodeParams.isPossiblyOffensive(), sourcePtNodeParams.isNotAWord(),
    249                 sourcePtNodeParams.isTerminal(), sourcePtNodeParams.hasShortcutTargets(),
    250                 true /* hasBigrams */,
    251                 sourcePtNodeParams.getCodePointCount() > 1 /* hasMultipleChars */);
    252     }
    253     return true;
    254 }
    255 
    256 bool Ver4PatriciaTrieNodeWriter::removeNgramEntry(const WordIdArrayView prevWordIds,
    257         const int wordId) {
    258     return mBigramPolicy->removeEntry(prevWordIds[0], wordId);
    259 }
    260 
    261 bool Ver4PatriciaTrieNodeWriter::updateAllBigramEntriesAndDeleteUselessEntries(
    262             const PtNodeParams *const sourcePtNodeParams, int *const outBigramEntryCount) {
    263     return mBigramPolicy->updateAllBigramEntriesAndDeleteUselessEntries(
    264             sourcePtNodeParams->getTerminalId(), outBigramEntryCount);
    265 }
    266 
    267 bool Ver4PatriciaTrieNodeWriter::updateAllPositionFields(
    268         const PtNodeParams *const toBeUpdatedPtNodeParams,
    269         const DictPositionRelocationMap *const dictPositionRelocationMap,
    270         int *const outBigramEntryCount) {
    271     int parentPos = toBeUpdatedPtNodeParams->getParentPos();
    272     if (parentPos != NOT_A_DICT_POS) {
    273         PtNodeWriter::PtNodePositionRelocationMap::const_iterator it =
    274                 dictPositionRelocationMap->mPtNodePositionRelocationMap.find(parentPos);
    275         if (it != dictPositionRelocationMap->mPtNodePositionRelocationMap.end()) {
    276             parentPos = it->second;
    277         }
    278     }
    279     int writingPos = toBeUpdatedPtNodeParams->getHeadPos()
    280             + DynamicPtWritingUtils::NODE_FLAG_FIELD_SIZE;
    281     // Write updated parent offset.
    282     if (!DynamicPtWritingUtils::writeParentPosOffsetAndAdvancePosition(mTrieBuffer,
    283             parentPos, toBeUpdatedPtNodeParams->getHeadPos(), &writingPos)) {
    284         return false;
    285     }
    286 
    287     // Updates children position.
    288     int childrenPos = toBeUpdatedPtNodeParams->getChildrenPos();
    289     if (childrenPos != NOT_A_DICT_POS) {
    290         PtNodeWriter::PtNodeArrayPositionRelocationMap::const_iterator it =
    291                 dictPositionRelocationMap->mPtNodeArrayPositionRelocationMap.find(childrenPos);
    292         if (it != dictPositionRelocationMap->mPtNodeArrayPositionRelocationMap.end()) {
    293             childrenPos = it->second;
    294         }
    295     }
    296     if (!updateChildrenPosition(toBeUpdatedPtNodeParams, childrenPos)) {
    297         return false;
    298     }
    299 
    300     // Counts bigram entries.
    301     if (outBigramEntryCount) {
    302         *outBigramEntryCount = mBigramPolicy->getBigramEntryConut(
    303                 toBeUpdatedPtNodeParams->getTerminalId());
    304     }
    305     return true;
    306 }
    307 
    308 bool Ver4PatriciaTrieNodeWriter::addShortcutTarget(const PtNodeParams *const ptNodeParams,
    309         const int *const targetCodePoints, const int targetCodePointCount,
    310         const int shortcutProbability) {
    311     if (!mShortcutPolicy->addNewShortcut(ptNodeParams->getTerminalId(),
    312             targetCodePoints, targetCodePointCount, shortcutProbability)) {
    313         AKLOGE("Cannot add new shortcut entry. terminalId: %d", ptNodeParams->getTerminalId());
    314         return false;
    315     }
    316     if (!ptNodeParams->hasShortcutTargets()) {
    317         // Update has shortcut targets flag.
    318         return updatePtNodeFlags(ptNodeParams->getHeadPos(),
    319                 ptNodeParams->isPossiblyOffensive(), ptNodeParams->isNotAWord(),
    320                 ptNodeParams->isTerminal(), true /* hasShortcutTargets */,
    321                 ptNodeParams->hasBigrams(),
    322                 ptNodeParams->getCodePointCount() > 1 /* hasMultipleChars */);
    323     }
    324     return true;
    325 }
    326 
    327 bool Ver4PatriciaTrieNodeWriter::updatePtNodeHasBigramsAndShortcutTargetsFlags(
    328         const PtNodeParams *const ptNodeParams) {
    329     const bool hasBigrams = mBuffers->getBigramDictContent()->getBigramListHeadPos(
    330             ptNodeParams->getTerminalId()) != NOT_A_DICT_POS;
    331     const bool hasShortcutTargets = mBuffers->getShortcutDictContent()->getShortcutListHeadPos(
    332             ptNodeParams->getTerminalId()) != NOT_A_DICT_POS;
    333     return updatePtNodeFlags(ptNodeParams->getHeadPos(), ptNodeParams->isPossiblyOffensive(),
    334             ptNodeParams->isNotAWord(), ptNodeParams->isTerminal(), hasShortcutTargets,
    335             hasBigrams, ptNodeParams->getCodePointCount() > 1 /* hasMultipleChars */);
    336 }
    337 
    338 bool Ver4PatriciaTrieNodeWriter::writePtNodeAndGetTerminalIdAndAdvancePosition(
    339         const PtNodeParams *const ptNodeParams, int *const outTerminalId,
    340         int *const ptNodeWritingPos) {
    341     const int nodePos = *ptNodeWritingPos;
    342     // Write dummy flags. The Node flags are updated with appropriate flags at the last step of the
    343     // PtNode writing.
    344     if (!DynamicPtWritingUtils::writeFlagsAndAdvancePosition(mTrieBuffer,
    345             0 /* nodeFlags */, ptNodeWritingPos)) {
    346         return false;
    347     }
    348     // Calculate a parent offset and write the offset.
    349     if (!DynamicPtWritingUtils::writeParentPosOffsetAndAdvancePosition(mTrieBuffer,
    350             ptNodeParams->getParentPos(), nodePos, ptNodeWritingPos)) {
    351         return false;
    352     }
    353     // Write code points
    354     if (!DynamicPtWritingUtils::writeCodePointsAndAdvancePosition(mTrieBuffer,
    355             ptNodeParams->getCodePoints(), ptNodeParams->getCodePointCount(), ptNodeWritingPos)) {
    356         return false;
    357     }
    358     int terminalId = Ver4DictConstants::NOT_A_TERMINAL_ID;
    359     if (!ptNodeParams->willBecomeNonTerminal()) {
    360         if (ptNodeParams->getTerminalId() != Ver4DictConstants::NOT_A_TERMINAL_ID) {
    361             terminalId = ptNodeParams->getTerminalId();
    362         } else if (ptNodeParams->isTerminal()) {
    363             // Write terminal information using a new terminal id.
    364             // Get a new unused terminal id.
    365             terminalId = mBuffers->getTerminalPositionLookupTable()->getNextTerminalId();
    366         }
    367     }
    368     const int isTerminal = terminalId != Ver4DictConstants::NOT_A_TERMINAL_ID;
    369     if (isTerminal) {
    370         // Update the lookup table.
    371         if (!mBuffers->getMutableTerminalPositionLookupTable()->setTerminalPtNodePosition(
    372                 terminalId, nodePos)) {
    373             return false;
    374         }
    375         // Write terminal Id.
    376         if (!mTrieBuffer->writeUintAndAdvancePosition(terminalId,
    377                 Ver4DictConstants::TERMINAL_ID_FIELD_SIZE, ptNodeWritingPos)) {
    378             return false;
    379         }
    380         if (outTerminalId) {
    381             *outTerminalId = terminalId;
    382         }
    383     }
    384     // Write children position
    385     if (!DynamicPtWritingUtils::writeChildrenPositionAndAdvancePosition(mTrieBuffer,
    386             ptNodeParams->getChildrenPos(), ptNodeWritingPos)) {
    387         return false;
    388     }
    389     return updatePtNodeFlags(nodePos, ptNodeParams->isPossiblyOffensive(),
    390             ptNodeParams->isNotAWord(), isTerminal, ptNodeParams->hasShortcutTargets(),
    391             ptNodeParams->hasBigrams(),
    392             ptNodeParams->getCodePointCount() > 1 /* hasMultipleChars */);
    393 }
    394 
    395 const ProbabilityEntry Ver4PatriciaTrieNodeWriter::createUpdatedEntryFrom(
    396         const ProbabilityEntry *const originalProbabilityEntry,
    397         const UnigramProperty *const unigramProperty) const {
    398     // TODO: Consolidate historical info and probability.
    399     if (mHeaderPolicy->hasHistoricalInfoOfWords()) {
    400         const HistoricalInfo &historicalInfoForUpdate = unigramProperty->getHistoricalInfo();
    401         const HistoricalInfo updatedHistoricalInfo =
    402                 ForgettingCurveUtils::createUpdatedHistoricalInfo(
    403                         originalProbabilityEntry->getHistoricalInfo(),
    404                         unigramProperty->getProbability(), &historicalInfoForUpdate, mHeaderPolicy);
    405         return originalProbabilityEntry->createEntryWithUpdatedHistoricalInfo(
    406                 &updatedHistoricalInfo);
    407     } else {
    408         return originalProbabilityEntry->createEntryWithUpdatedProbability(
    409                 unigramProperty->getProbability());
    410     }
    411 }
    412 
    413 bool Ver4PatriciaTrieNodeWriter::updatePtNodeFlags(const int ptNodePos,
    414         const bool isBlacklisted, const bool isNotAWord, const bool isTerminal,
    415         const bool hasShortcutTargets, const bool hasBigrams, const bool hasMultipleChars) {
    416     // Create node flags and write them.
    417     PatriciaTrieReadingUtils::NodeFlags nodeFlags =
    418             PatriciaTrieReadingUtils::createAndGetFlags(isBlacklisted, isNotAWord, isTerminal,
    419                     hasShortcutTargets, hasBigrams, hasMultipleChars,
    420                     CHILDREN_POSITION_FIELD_SIZE);
    421     if (!DynamicPtWritingUtils::writeFlags(mTrieBuffer, nodeFlags, ptNodePos)) {
    422         AKLOGE("Cannot write PtNode flags. flags: %x, pos: %d", nodeFlags, ptNodePos);
    423         return false;
    424     }
    425     return true;
    426 }
    427 
    428 bool Ver4PatriciaTrieNodeWriter::suppressUnigramEntry(const PtNodeParams *const ptNodeParams) {
    429     if (!mHeaderPolicy->hasHistoricalInfoOfWords()) {
    430         // Require historical info to suppress unigram entry.
    431         return false;
    432     }
    433     const HistoricalInfo suppressedHistorycalInfo(0 /* timestamp */, 0 /* level */, 0 /* count */);
    434     const ProbabilityEntry probabilityEntryToWrite =
    435             ProbabilityEntry().createEntryWithUpdatedHistoricalInfo(&suppressedHistorycalInfo);
    436     return mBuffers->getMutableProbabilityDictContent()->setProbabilityEntry(
    437             ptNodeParams->getTerminalId(), &probabilityEntryToWrite);
    438 }
    439 
    440 } // namespace v402
    441 } // namespace backward
    442 } // namespace latinime
    443