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

native/jni/src/suggest/core/dicnode/dic_node_proximity_filter.h

deleted100644 → 0
+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

native/jni/src/suggest/core/dicnode/dic_node_utils.cpp

+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);

    }

}

native/jni/src/suggest/core/dicnode/dic_node_utils.h

+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

native/jni/src/suggest/core/policy/dictionary_structure_with_buffer_policy.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,

native/jni/src/suggest/core/suggest.cpp

+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);