Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7fd9667d authored by Keisuke Kuroyanagi's avatar Keisuke Kuroyanagi
Browse files

Remove NodeFilter.

Change-Id: I27d905dd3581cbb0e67d071dba04066aaa2ba22e
parent dfecc86f
Loading
Loading
Loading
Loading
+0 −58
Original line number Diff line number Diff line
/*
 * 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_DIC_NODE_PROXIMITY_FILTER_H
#define LATINIME_DIC_NODE_PROXIMITY_FILTER_H

#include "defines.h"
#include "suggest/core/layout/proximity_info_state.h"
#include "suggest/core/layout/proximity_info_utils.h"
#include "suggest/core/policy/dictionary_structure_with_buffer_policy.h"

namespace latinime {

class DicNodeProximityFilter : public DictionaryStructureWithBufferPolicy::NodeFilter {
 public:
    DicNodeProximityFilter(const ProximityInfoState *const pInfoState,
            const int pointIndex, const bool exactOnly)
            : mProximityInfoState(pInfoState), mPointIndex(pointIndex), mExactOnly(exactOnly) {}

    bool isFilteredOut(const int codePoint) const {
        return !isProximityCodePoint(codePoint);
    }

 private:
    DISALLOW_IMPLICIT_CONSTRUCTORS(DicNodeProximityFilter);

    const ProximityInfoState *const mProximityInfoState;
    const int mPointIndex;
    const bool mExactOnly;

    // TODO: Move to proximity info state
    bool isProximityCodePoint(const int codePoint) const {
        if (!mProximityInfoState) {
            return true;
        }
        if (mExactOnly) {
            return mProximityInfoState->getPrimaryCodePointAt(mPointIndex) == codePoint;
        }
        const ProximityType matchedId = mProximityInfoState->getProximityType(
                mPointIndex, codePoint, true /* checkProximityChars */);
        return ProximityInfoUtils::isMatchOrProximityChar(matchedId);
    }
};
} // namespace latinime
#endif // LATINIME_DIC_NODE_PROXIMITY_FILTER_H
+2 −25
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@
#include <cstring>

#include "suggest/core/dicnode/dic_node.h"
#include "suggest/core/dicnode/dic_node_proximity_filter.h"
#include "suggest/core/dicnode/dic_node_vector.h"
#include "suggest/core/dictionary/multi_bigram_map.h"
#include "suggest/core/dictionary/probability_utils.h"
@@ -52,38 +51,16 @@ namespace latinime {
///////////////////////////////////
// Traverse node expansion utils //
///////////////////////////////////

/* static */ void DicNodeUtils::createAndGetPassingChildNode(DicNode *dicNode,
        const DicNodeProximityFilter *const childrenFilter,
        DicNodeVector *childDicNodes) {
    // Passing multiple chars node. No need to traverse child
    const int codePoint = dicNode->getNodeTypedCodePoint();
    const int baseLowerCaseCodePoint = CharUtils::toBaseLowerCase(codePoint);
    if (!childrenFilter->isFilteredOut(codePoint)
            || CharUtils::isIntentionalOmissionCodePoint(baseLowerCaseCodePoint)) {
        childDicNodes->pushPassingChild(dicNode);
    }
}

/* static */ void DicNodeUtils::getAllChildDicNodes(DicNode *dicNode,
        const DictionaryStructureWithBufferPolicy *const dictionaryStructurePolicy,
        DicNodeVector *childDicNodes) {
    getProximityChildDicNodes(dicNode, dictionaryStructurePolicy, 0, 0, false, childDicNodes);
}

/* static */ void DicNodeUtils::getProximityChildDicNodes(DicNode *dicNode,
        const DictionaryStructureWithBufferPolicy *const dictionaryStructurePolicy,
        const ProximityInfoState *pInfoState, const int pointIndex, bool exactOnly,
        DicNodeVector *childDicNodes) {
    if (dicNode->isTotalInputSizeExceedingLimit()) {
        return;
    }
    const DicNodeProximityFilter childrenFilter(pInfoState, pointIndex, exactOnly);
    if (!dicNode->isLeavingNode()) {
        DicNodeUtils::createAndGetPassingChildNode(dicNode, &childrenFilter, childDicNodes);
        childDicNodes->pushPassingChild(dicNode);
    } else {
        dictionaryStructurePolicy->createAndGetAllChildNodes(dicNode,
                &childrenFilter, childDicNodes);
        dictionaryStructurePolicy->createAndGetAllChildNodes(dicNode, childDicNodes);
    }
}

+0 −9
Original line number Diff line number Diff line
@@ -24,10 +24,8 @@
namespace latinime {

class DicNode;
class DicNodeProximityFilter;
class DicNodeVector;
class DictionaryStructureWithBufferPolicy;
class ProximityInfoState;
class MultiBigramMap;

class DicNodeUtils {
@@ -47,11 +45,6 @@ class DicNodeUtils {
    static float getBigramNodeImprobability(
            const DictionaryStructureWithBufferPolicy *const dictionaryStructurePolicy,
            const DicNode *const node, MultiBigramMap *const multiBigramMap);
    // TODO: Move to private
    static void getProximityChildDicNodes(DicNode *dicNode,
            const DictionaryStructureWithBufferPolicy *const dictionaryStructurePolicy,
            const ProximityInfoState *pInfoState, const int pointIndex, bool exactOnly,
            DicNodeVector *childDicNodes);

 private:
    DISALLOW_IMPLICIT_CONSTRUCTORS(DicNodeUtils);
@@ -61,8 +54,6 @@ class DicNodeUtils {
    static int getBigramNodeProbability(
            const DictionaryStructureWithBufferPolicy *const dictionaryStructurePolicy,
            const DicNode *const node, MultiBigramMap *multiBigramMap);
    static void createAndGetPassingChildNode(DicNode *dicNode,
            const DicNodeProximityFilter *const childrenFilter, DicNodeVector *childDicNodes);
};
} // namespace latinime
#endif // LATINIME_DIC_NODE_UTILS_H
+1 −14
Original line number Diff line number Diff line
@@ -33,25 +33,12 @@ class DictionaryShortcutsStructurePolicy;
 */
class DictionaryStructureWithBufferPolicy {
 public:
    // This provides a filtering method for filtering new node.
    class NodeFilter {
     public:
        virtual bool isFilteredOut(const int codePoint) const = 0;

     protected:
        NodeFilter() {}
        virtual ~NodeFilter() {}

     private:
        DISALLOW_COPY_AND_ASSIGN(NodeFilter);
    };

    virtual ~DictionaryStructureWithBufferPolicy() {}

    virtual int getRootPosition() const = 0;

    virtual void createAndGetAllChildNodes(const DicNode *const dicNode,
            const NodeFilter *const nodeFilter, DicNodeVector *const childDicNodes) const = 0;
            DicNodeVector *const childDicNodes) const = 0;

    virtual int getCodePointsAndProbabilityAndReturnCodePointCount(
            const int nodePos, const int maxCodePointCount, int *const outCodePoints,
+22 −10
Original line number Diff line number Diff line
@@ -456,7 +456,6 @@ void Suggest::processDicNodeAsOmission(
        Weighting::addCostAndForwardInputIndex(WEIGHTING, CT_OMISSION, traverseSession,
                dicNode, childDicNode, 0 /* multiBigramMap */);
        weightChildNode(traverseSession, childDicNode);

        if (!TRAVERSAL->isPossibleOmissionChildNode(traverseSession, dicNode, childDicNode)) {
            continue;
        }
@@ -472,11 +471,14 @@ void Suggest::processDicNodeAsInsertion(DicTraverseSession *traverseSession,
        DicNode *dicNode) const {
    const int16_t pointIndex = dicNode->getInputIndex(0);
    DicNodeVector childDicNodes;
    DicNodeUtils::getProximityChildDicNodes(dicNode,
            traverseSession->getDictionaryStructurePolicy(),
            traverseSession->getProximityInfoState(0), pointIndex + 1, true, &childDicNodes);
    DicNodeUtils::getAllChildDicNodes(dicNode, traverseSession->getDictionaryStructurePolicy(),
            &childDicNodes);
    const int size = childDicNodes.getSizeAndLock();
    for (int i = 0; i < size; i++) {
        if (traverseSession->getProximityInfoState(0)->getPrimaryCodePointAt(pointIndex + 1)
                != childDicNodes[i]->getNodeCodePoint()) {
            continue;
        }
        DicNode *const childDicNode = childDicNodes[i];
        Weighting::addCostAndForwardInputIndex(WEIGHTING, CT_INSERTION, traverseSession,
                dicNode, childDicNode, 0 /* multiBigramMap */);
@@ -491,19 +493,29 @@ void Suggest::processDicNodeAsTransposition(DicTraverseSession *traverseSession,
        DicNode *dicNode) const {
    const int16_t pointIndex = dicNode->getInputIndex(0);
    DicNodeVector childDicNodes1;
    DicNodeUtils::getProximityChildDicNodes(dicNode,
            traverseSession->getDictionaryStructurePolicy(),
            traverseSession->getProximityInfoState(0), pointIndex + 1, false, &childDicNodes1);
    DicNodeUtils::getAllChildDicNodes(dicNode, traverseSession->getDictionaryStructurePolicy(),
            &childDicNodes1);
    const int childSize1 = childDicNodes1.getSizeAndLock();
    for (int i = 0; i < childSize1; i++) {
        const ProximityType matchedId1 = traverseSession->getProximityInfoState(0)
                ->getProximityType(pointIndex + 1, childDicNodes1[i]->getNodeCodePoint(),
                        true /* checkProximityChars */);
        if (!ProximityInfoUtils::isMatchOrProximityChar(matchedId1)) {
            continue;
        }
        if (childDicNodes1[i]->hasChildren()) {
            DicNodeVector childDicNodes2;
            DicNodeUtils::getProximityChildDicNodes(
                    childDicNodes1[i], traverseSession->getDictionaryStructurePolicy(),
                    traverseSession->getProximityInfoState(0), pointIndex, false, &childDicNodes2);
            DicNodeUtils::getAllChildDicNodes(childDicNodes1[i],
                    traverseSession->getDictionaryStructurePolicy(), &childDicNodes2);
            const int childSize2 = childDicNodes2.getSizeAndLock();
            for (int j = 0; j < childSize2; j++) {
                DicNode *const childDicNode2 = childDicNodes2[j];
                const ProximityType matchedId2 = traverseSession->getProximityInfoState(0)
                        ->getProximityType(pointIndex, childDicNode2->getNodeCodePoint(),
                                true /* checkProximityChars */);
                if (!ProximityInfoUtils::isMatchOrProximityChar(matchedId2)) {
                    continue;
                }
                Weighting::addCostAndForwardInputIndex(WEIGHTING, CT_TRANSPOSITION,
                        traverseSession, childDicNodes1[i], childDicNode2, 0 /* multiBigramMap */);
                processExpandedDicNode(traverseSession, childDicNode2);
Loading