nyancrimew
/
LatinIME
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

am ffd08e37: Reorganize file and class names for typing and gesture 

* commit 'ffd08e37881e9e7f403d04c1a1a8aaba409d36b5':
  Reorganize file and class names for typing and gesture
main
Ken Wakasa 2012-12-20 07:35:15 -08:00 committed by Android Git Automerger
parent 69ff353d4f ffd08e3788
commit 82617a23f4
9 changed files with 105 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
native/jni/Android.mk
View File

@ -26,7 +26,7 @@ include $(CLEAR_VARS)
LATIN_IME_SRC_DIR := src
LATIN_IME_SRC_FULLPATH_DIR := $(LOCAL_PATH)/$(LATIN_IME_SRC_DIR)
LOCAL_C_INCLUDES += $(LATIN_IME_SRC_FULLPATH_DIR) $(LATIN_IME_SRC_FULLPATH_DIR)/gesture
LOCAL_C_INCLUDES += $(LATIN_IME_SRC_FULLPATH_DIR) $(LATIN_IME_SRC_FULLPATH_DIR)/suggest
LOCAL_CFLAGS += -Werror -Wall -Wextra -Weffc++ -Wformat=2 -Wcast-qual -Wcast-align \
-Wwrite-strings -Wfloat-equal -Wpointer-arith -Winit-self -Wredundant-decls -Wno-system-headers
@ -57,8 +57,8 @@ LATIN_IME_CORE_SRC_FILES := \
proximity_info_state.cpp \
unigram_dictionary.cpp \
words_priority_queue.cpp \
gesture/gesture_decoder_wrapper.cpp \
gesture/typing_decoder_wrapper.cpp
suggest/gesture_suggest.cpp \
suggest/typing_suggest.cpp
LOCAL_SRC_FILES := \
$(LATIN_IME_JNI_SRC_FILES) \

8
native/jni/src/dictionary.cpp
View File

@ -23,7 +23,7 @@
#include "defines.h"
#include "dictionary.h"
#include "dic_traverse_wrapper.h"
#include "gesture_decoder_wrapper.h"
#include "gesture_suggest.h"
#include "unigram_dictionary.h"
namespace latinime {
@ -36,7 +36,7 @@ Dictionary::Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust,
mUnigramDictionary(new UnigramDictionary(mOffsetDict, maxWordLength, maxWords,
BinaryFormat::getFlags(mDict))),
mBigramDictionary(new BigramDictionary(mOffsetDict, maxWordLength, maxPredictions)),
mGestureDecoder(new GestureDecoderWrapper(maxWordLength, maxWords)) {
mGestureSuggest(new GestureSuggest(maxWordLength, maxWords)) {
if (DEBUG_DICT) {
if (MAX_WORD_LENGTH_INTERNAL < maxWordLength) {
AKLOGI("Max word length (%d) is greater than %d",
@ -49,7 +49,7 @@ Dictionary::Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust,
Dictionary::~Dictionary() {
delete mUnigramDictionary;
delete mBigramDictionary;
delete mGestureDecoder;
delete mGestureSuggest;
}
int Dictionary::getSuggestions(ProximityInfo *proximityInfo, void *traverseSession,
@ -61,7 +61,7 @@ int Dictionary::getSuggestions(ProximityInfo *proximityInfo, void *traverseSessi
if (isGesture) {
DicTraverseWrapper::initDicTraverseSession(
traverseSession, this, prevWordChars, prevWordLength);
result = mGestureDecoder->getSuggestions(proximityInfo, traverseSession,
result = mGestureSuggest->getSuggestions(proximityInfo, traverseSession,
xcoordinates, ycoordinates, times, pointerIds, codes, codesSize, commitPoint,
outWords, frequencies, spaceIndices, outputTypes);
if (DEBUG_DICT) {

4
native/jni/src/dictionary.h
View File

@ -24,8 +24,8 @@
namespace latinime {
class BigramDictionary;
class IncrementalDecoderInterface;
class ProximityInfo;
class SuggestInterface;
class UnigramDictionary;
class Dictionary {
@ -83,7 +83,7 @@ class Dictionary {
const UnigramDictionary *mUnigramDictionary;
const BigramDictionary *mBigramDictionary;
IncrementalDecoderInterface *mGestureDecoder;
SuggestInterface *mGestureSuggest;
};
// public static utility methods

67
native/jni/src/gesture/typing_decoder_wrapper.h
View File

@ -1,67 +0,0 @@
/*
* Copyright (C) 2012 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_TYPING_DECODER_WRAPPER_H
#define LATINIME_TYPING_DECODER_WRAPPER_H
#include "defines.h"
#include "incremental_decoder_interface.h"
namespace latinime {
class UnigramDictionary;
class BigramDictionary;
class ProximityInfo;
class TypingDecoderWrapper : public IncrementalDecoderInterface {
public:
TypingDecoderWrapper(const int maxWordLength, const int maxWords)
: mIncrementalDecoderInterface(getIncrementalDecoderInstance(maxWordLength, maxWords)) {
}
virtual ~TypingDecoderWrapper();
int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs, int *inputYs,
int *times, int *pointerIds, int *codes, int inputSize, int commitPoint, int *outWords,
int *frequencies, int *outputIndices, int *outputTypes) const {
if (!mIncrementalDecoderInterface) {
return 0;
}
return mIncrementalDecoderInterface->getSuggestions(pInfo, traverseSession, inputXs,
inputYs, times, pointerIds, codes, inputSize, commitPoint, outWords, frequencies,
outputIndices, outputTypes);
}
static void setIncrementalDecoderFactoryMethod(
IncrementalDecoderInterface *(*factoryMethod)(int, int)) {
sIncrementalDecoderFactoryMethod = factoryMethod;
}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(TypingDecoderWrapper);
static IncrementalDecoderInterface *getIncrementalDecoderInstance(int maxWordLength,
int maxWords) {
if (sIncrementalDecoderFactoryMethod) {
return sIncrementalDecoderFactoryMethod(maxWordLength, maxWords);
}
return 0;
}
static IncrementalDecoderInterface *(*sIncrementalDecoderFactoryMethod)(int, int);
IncrementalDecoderInterface *mIncrementalDecoderInterface;
};
} // namespace latinime
#endif // LATINIME_TYPING_DECODER_WRAPPER_H

9
native/jni/src/gesture/typing_decoder_wrapper.cpp → native/jni/src/suggest/gesture_suggest.cpp
View File

@ -14,13 +14,12 @@
* limitations under the License.
*/
#include "typing_decoder_wrapper.h"
#include "gesture_suggest.h"
namespace latinime {
IncrementalDecoderInterface *
(*TypingDecoderWrapper::sIncrementalDecoderFactoryMethod)(int, int) = 0;
SuggestInterface *(*GestureSuggest::sGestureSuggestFactoryMethod)(int, int) = 0;
TypingDecoderWrapper::~TypingDecoderWrapper() {
delete mIncrementalDecoderInterface;
GestureSuggest::~GestureSuggest() {
delete mSuggestInterface;
}
} // namespace latinime

39
native/jni/src/gesture/gesture_decoder_wrapper.h → native/jni/src/suggest/gesture_suggest.h
View File

@ -14,53 +14,50 @@
* limitations under the License.
*/
#ifndef LATINIME_GESTURE_DECODER_WRAPPER_H
#define LATINIME_GESTURE_DECODER_WRAPPER_H
#ifndef LATINIME_GESTURE_SUGGEST_H
#define LATINIME_GESTURE_SUGGEST_H
#include "defines.h"
#include "incremental_decoder_interface.h"
#include "suggest_interface.h"
namespace latinime {
class UnigramDictionary;
class BigramDictionary;
class ProximityInfo;
class GestureDecoderWrapper : public IncrementalDecoderInterface {
class GestureSuggest : public SuggestInterface {
public:
GestureDecoderWrapper(const int maxWordLength, const int maxWords)
: mIncrementalDecoderInterface(getGestureDecoderInstance(maxWordLength, maxWords)) {
GestureSuggest(const int maxWordLength, const int maxWords)
: mSuggestInterface(getGestureSuggestInstance(maxWordLength, maxWords)) {
}
virtual ~GestureDecoderWrapper();
virtual ~GestureSuggest();
int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs, int *inputYs,
int *times, int *pointerIds, int *codes, int inputSize, int commitPoint, int *outWords,
int *frequencies, int *outputIndices, int *outputTypes) const {
if (!mIncrementalDecoderInterface) {
if (!mSuggestInterface) {
return 0;
}
return mIncrementalDecoderInterface->getSuggestions(pInfo, traverseSession, inputXs,
return mSuggestInterface->getSuggestions(pInfo, traverseSession, inputXs,
inputYs, times, pointerIds, codes, inputSize, commitPoint, outWords, frequencies,
outputIndices, outputTypes);
}
static void setGestureDecoderFactoryMethod(
IncrementalDecoderInterface *(*factoryMethod)(int, int)) {
sGestureDecoderFactoryMethod = factoryMethod;
static void setGestureSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int, int)) {
sGestureSuggestFactoryMethod = factoryMethod;
}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(GestureDecoderWrapper);
static IncrementalDecoderInterface *getGestureDecoderInstance(int maxWordLength, int maxWords) {
if (sGestureDecoderFactoryMethod) {
return sGestureDecoderFactoryMethod(maxWordLength, maxWords);
DISALLOW_IMPLICIT_CONSTRUCTORS(GestureSuggest);
static SuggestInterface *getGestureSuggestInstance(int maxWordLength, int maxWords) {
if (sGestureSuggestFactoryMethod) {
return sGestureSuggestFactoryMethod(maxWordLength, maxWords);
}
return 0;
}
static IncrementalDecoderInterface *(*sGestureDecoderFactoryMethod)(int, int);
IncrementalDecoderInterface *mIncrementalDecoderInterface;
static SuggestInterface *(*sGestureSuggestFactoryMethod)(int, int);
SuggestInterface *mSuggestInterface;
};
} // namespace latinime
#endif // LATINIME_GESTURE_DECODER_WRAPPER_H
#endif // LATINIME_GESTURE_SUGGEST_H

16
native/jni/src/gesture/incremental_decoder_interface.h → native/jni/src/suggest/suggest_interface.h
View File

@ -14,26 +14,24 @@
* limitations under the License.
*/
#ifndef LATINIME_INCREMENTAL_DECODER_INTERFACE_H
#define LATINIME_INCREMENTAL_DECODER_INTERFACE_H
#ifndef LATINIME_SUGGEST_INTERFACE_H
#define LATINIME_SUGGEST_INTERFACE_H
#include "defines.h"
namespace latinime {
class UnigramDictionary;
class BigramDictionary;
class ProximityInfo;
class IncrementalDecoderInterface {
class SuggestInterface {
public:
virtual int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs,
int *inputYs, int *times, int *pointerIds, int *codes, int inputSize, int commitPoint,
int *outWords, int *frequencies, int *outputIndices, int *outputTypes) const = 0;
IncrementalDecoderInterface() { };
virtual ~IncrementalDecoderInterface() { };
SuggestInterface() { };
virtual ~SuggestInterface() { };
private:
DISALLOW_COPY_AND_ASSIGN(IncrementalDecoderInterface);
DISALLOW_COPY_AND_ASSIGN(SuggestInterface);
};
} // namespace latinime
#endif // LATINIME_INCREMENTAL_DECODER_INTERFACE_H
#endif // LATINIME_SUGGEST_INTERFACE_H

9
native/jni/src/gesture/gesture_decoder_wrapper.cpp → native/jni/src/suggest/typing_suggest.cpp
View File

@ -14,13 +14,12 @@
* limitations under the License.
*/
#include "gesture_decoder_wrapper.h"
#include "typing_suggest.h"
namespace latinime {
IncrementalDecoderInterface *
(*GestureDecoderWrapper::sGestureDecoderFactoryMethod)(int, int) = 0;
SuggestInterface *(*TypingSuggest::sTypingSuggestFactoryMethod)(int, int) = 0;
GestureDecoderWrapper::~GestureDecoderWrapper() {
delete mIncrementalDecoderInterface;
TypingSuggest::~TypingSuggest() {
delete mSuggestInterface;
}
} // namespace latinime

63
native/jni/src/suggest/typing_suggest.h Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright (C) 2012 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_TYPING_SUGGEST_H
#define LATINIME_TYPING_SUGGEST_H
#include "defines.h"
#include "suggest_interface.h"
namespace latinime {
class ProximityInfo;
class TypingSuggest : public SuggestInterface {
public:
TypingSuggest(const int maxWordLength, const int maxWords)
: mSuggestInterface(getTypingSuggestInstance(maxWordLength, maxWords)) {
}
virtual ~TypingSuggest();
int getSuggestions(ProximityInfo *pInfo, void *traverseSession, int *inputXs, int *inputYs,
int *times, int *pointerIds, int *codes, int inputSize, int commitPoint, int *outWords,
int *frequencies, int *outputIndices, int *outputTypes) const {
if (!mSuggestInterface) {
return 0;
}
return mSuggestInterface->getSuggestions(pInfo, traverseSession, inputXs,
inputYs, times, pointerIds, codes, inputSize, commitPoint, outWords, frequencies,
outputIndices, outputTypes);
}
static void setTypingSuggestFactoryMethod(SuggestInterface *(*factoryMethod)(int, int)) {
sTypingSuggestFactoryMethod = factoryMethod;
}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(TypingSuggest);
static SuggestInterface *getTypingSuggestInstance(int maxWordLength, int maxWords) {
if (sTypingSuggestFactoryMethod) {
return sTypingSuggestFactoryMethod(maxWordLength, maxWords);
}
return 0;
}
static SuggestInterface *(*sTypingSuggestFactoryMethod)(int, int);
SuggestInterface *mSuggestInterface;
};
} // namespace latinime
#endif // LATINIME_TYPING_SUGGEST_H