Merge "Remove NodeFilter." (c3dc9021) · Commits · e / os / android_packages_inputmethods_LatinIME

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