59b516a118
The 3rdparty files are now compiled as part of the corresponding input method, so that the project files can be written without using platform specific linker flags.
112 lines
3.8 KiB
C++
112 lines
3.8 KiB
C++
/*
|
|
* Copyright (C) 2009 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 PINYINIME_INCLUDE_SPELLINGTABLE_H__
|
|
#define PINYINIME_INCLUDE_SPELLINGTABLE_H__
|
|
|
|
#include <stdlib.h>
|
|
#include "./dictdef.h"
|
|
|
|
namespace ime_pinyin {
|
|
|
|
#ifdef ___BUILD_MODEL___
|
|
|
|
const size_t kMaxSpellingSize = kMaxPinyinSize;
|
|
|
|
typedef struct {
|
|
char str[kMaxSpellingSize + 1];
|
|
double freq;
|
|
} RawSpelling, *PRawSpelling;
|
|
|
|
// This class is used to store the spelling strings
|
|
// The length of the input spelling string should be less or equal to the
|
|
// spelling_size_ (set by init_table). If the input string is too long,
|
|
// we only keep its first spelling_size_ chars.
|
|
class SpellingTable {
|
|
private:
|
|
static const size_t kNotSupportNum = 3;
|
|
static const char kNotSupportList[kNotSupportNum][kMaxSpellingSize + 1];
|
|
|
|
bool need_score_;
|
|
|
|
size_t spelling_max_num_;
|
|
|
|
RawSpelling *raw_spellings_;
|
|
|
|
// Used to store spelling strings. If the spelling table needs to calculate
|
|
// score, an extra char after each spelling string is the score.
|
|
// An item with a lower score has a higher probability.
|
|
char *spelling_buf_;
|
|
size_t spelling_size_;
|
|
|
|
double total_freq_;
|
|
|
|
size_t spelling_num_;
|
|
|
|
double score_amplifier_;
|
|
|
|
unsigned char average_score_;
|
|
|
|
// If frozen is true, put_spelling() and contain() are not allowed to call.
|
|
bool frozen_;
|
|
|
|
size_t get_hash_pos(const char* spelling_str);
|
|
size_t hash_pos_next(size_t hash_pos);
|
|
void free_resource();
|
|
public:
|
|
SpellingTable();
|
|
~SpellingTable();
|
|
|
|
// pure_spl_size is the pure maximum spelling string size. For example,
|
|
// "zhuang" is the longgest item in Pinyin, so pure_spl_size should be 6.
|
|
// spl_max_num is the maximum number of spelling strings to store.
|
|
// need_score is used to indicate whether the caller needs to calculate a
|
|
// score for each spelling.
|
|
bool init_table(size_t pure_spl_size, size_t spl_max_num, bool need_score);
|
|
|
|
// Put a spelling string to the table.
|
|
// It always returns false if called after arrange() withtout a new
|
|
// init_table() operation.
|
|
// freq is the spelling's occuring count.
|
|
// If the spelling has been in the table, occuring count will accumulated.
|
|
bool put_spelling(const char* spelling_str, double spl_count);
|
|
|
|
// Test whether a spelling string is in the table.
|
|
// It always returns false, when being called after arrange() withtout a new
|
|
// init_table() operation.
|
|
bool contain(const char* spelling_str);
|
|
|
|
// Sort the spelling strings and put them from the begin of the buffer.
|
|
// Return the pointer of the sorted spelling strings.
|
|
// item_size and spl_num return the item size and number of spelling.
|
|
// Because each spelling uses a '\0' as terminator, the returned item_size is
|
|
// at least one char longer than the spl_size parameter specified by
|
|
// init_table(). If the table is initialized to calculate score, item_size
|
|
// will be increased by 1, and current_spl_str[item_size - 1] stores an
|
|
// unsinged char score.
|
|
// An item with a lower score has a higher probability.
|
|
// Do not call put_spelling() and contains() after arrange().
|
|
const char* arrange(size_t *item_size, size_t *spl_num);
|
|
|
|
float get_score_amplifier();
|
|
|
|
unsigned char get_average_score();
|
|
};
|
|
#endif // ___BUILD_MODEL___
|
|
}
|
|
|
|
#endif // PINYINIME_INCLUDE_SPELLINGTABLE_H__
|