diff options
author | Peng Wu <alexepico@gmail.com> | 2017-04-25 13:28:26 +0800 |
---|---|---|
committer | Peng Wu <alexepico@gmail.com> | 2017-04-25 13:30:29 +0800 |
commit | 32f157d1d204a1d1c4ad3825b8488572a871c86b (patch) | |
tree | 4230c093283eb0d3dd9e0f29a38e8e726a6b6577 /src/zhuyin.h | |
parent | 7fb6cd3c797cc5bea200651db73327dbed6f8899 (diff) | |
download | libpinyin-32f157d1d204a1d1c4ad3825b8488572a871c86b.tar.gz libpinyin-32f157d1d204a1d1c4ad3825b8488572a871c86b.tar.xz libpinyin-32f157d1d204a1d1c4ad3825b8488572a871c86b.zip |
import zhuyin.h
Diffstat (limited to 'src/zhuyin.h')
-rw-r--r-- | src/zhuyin.h | 712 |
1 files changed, 712 insertions, 0 deletions
diff --git a/src/zhuyin.h b/src/zhuyin.h new file mode 100644 index 0000000..66095f9 --- /dev/null +++ b/src/zhuyin.h @@ -0,0 +1,712 @@ +/* + * libpinyin + * Library to deal with pinyin. + * + * Copyright (C) 2017 Peng Wu <alexepico@gmail.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef ZHUYIN_H +#define ZHUYIN_H + + +#include "novel_types.h" +#include "zhuyin_custom2.h" + + +G_BEGIN_DECLS + +typedef struct _ChewingKey ChewingKey; +typedef struct _ChewingKeyRest ChewingKeyRest; + +typedef struct _zhuyin_context_t zhuyin_context_t; +typedef struct _zhuyin_instance_t zhuyin_instance_t; +typedef struct _lookup_candidate_t lookup_candidate_t; + +typedef struct _import_iterator_t import_iterator_t; + +typedef enum _lookup_candidate_type_t{ + BEST_MATCH_CANDIDATE = 1, + NORMAL_CANDIDATE_AFTER_CURSOR, + NORMAL_CANDIDATE_BEFORE_CURSOR, + ZOMBIE_CANDIDATE +} lookup_candidate_type_t; + +/** + * zhuyin_init: + * @systemdir: the system wide language model data directory. + * @userdir: the user's language model data directory. + * @returns: the newly created pinyin context, NULL if failed. + * + * Create a new pinyin context. + * + */ +zhuyin_context_t * zhuyin_init(const char * systemdir, const char * userdir); + +/** + * zhuyin_load_phrase_library: + * @context: the zhuyin context. + * @index: the phrase index to be loaded. + * @returns: whether the load succeeded. + * + * Load the sub phrase library of the index. + * + */ +bool zhuyin_load_phrase_library(zhuyin_context_t * context, + guint8 index); + +/** + * zhuyin_unload_phrase_library: + * @context: the zhuyin context. + * @index: the phrase index to be unloaded. + * @returns: whether the unload succeeded. + * + * Unload the sub phrase library of the index. + * + */ +bool zhuyin_unload_phrase_library(zhuyin_context_t * context, + guint8 index); + +/** + * zhuyin_begin_add_phrases: + * @context: the zhuyin context. + * @index: the phrase index to be imported. + * @returns: the import iterator. + * + * Begin to add phrases. + * + */ +import_iterator_t * zhuyin_begin_add_phrases(zhuyin_context_t * context, + guint8 index); + +/** + * zhuyin_iterator_add_phrase: + * @iter: the import iterator. + * @phrase: the phrase string. + * @pinyin: the pinyin string. + * @count: the count of the phrase/pinyin pair, -1 to use the default value. + * @returns: whether the add operation succeeded. + * + * Add a pair of phrase and pinyin with count. + * + */ +bool zhuyin_iterator_add_phrase(import_iterator_t * iter, + const char * phrase, + const char * pinyin, + gint count); + +/** + * zhuyin_end_add_phrases: + * @iter: the import iterator. + * + * End adding phrases. + * + */ +void zhuyin_end_add_phrases(import_iterator_t * iter); + +/** + * zhuyin_save: + * @context: the zhuyin context to be saved into user directory. + * @returns: whether the save succeeded. + * + * Save the user's self-learning information of the zhuyin context. + * + */ +bool zhuyin_save(zhuyin_context_t * context); + +/** + * zhuyin_set_chewing_scheme: + * @context: the zhuyin context. + * @scheme: the chewing scheme. + * @returns: whether the set chewing scheme succeeded. + * + * Change the chewing scheme of the zhuyin context. + * + */ +bool zhuyin_set_chewing_scheme(zhuyin_context_t * context, + ZhuyinScheme scheme); + +/** + * zhuyin_set_full_pinyin_scheme: + * @context: the zhuyin context. + * @scheme: the full pinyin scheme. + * @returns: whether the set full pinyin scheme succeeded. + * + * Change the full pinyin scheme of the zhuyin context. + * + */ +bool zhuyin_set_full_pinyin_scheme(zhuyin_context_t * context, + ZhuyinScheme scheme); + +/** + * zhuyin_fini: + * @context: the zhuyin context. + * + * Finalize the zhuyin context. + * + */ +void zhuyin_fini(zhuyin_context_t * context); + + +/** + * zhuyin_mask_out: + * @context: the zhuyin context. + * @mask: the mask. + * @value: the value. + * @returns: whether the mask out operation is successful. + * + * Mask out the matched phrase tokens. + * + */ +bool zhuyin_mask_out(zhuyin_context_t * context, + phrase_token_t mask, + phrase_token_t value); + + +/** + * zhuyin_set_options: + * @context: the zhuyin context. + * @options: the pinyin options of the zhuyin context. + * @returns: whether the set options scheme succeeded. + * + * Set the options of the zhuyin context. + * + */ +bool zhuyin_set_options(zhuyin_context_t * context, + pinyin_option_t options); + +/** + * zhuyin_alloc_instance: + * @context: the zhuyin context. + * @returns: the newly allocated pinyin instance, NULL if failed. + * + * Allocate a new pinyin instance from the context. + * + */ +zhuyin_instance_t * zhuyin_alloc_instance(zhuyin_context_t * context); + +/** + * zhuyin_free_instance: + * @instance: the zhuyin instance. + * + * Free the zhuyin instance. + * + */ +void zhuyin_free_instance(zhuyin_instance_t * instance); + + +/** + * zhuyin_guess_sentence: + * @instance: the zhuyin instance. + * @returns: whether the sentence are guessed successfully. + * + * Guess a sentence from the saved pinyin keys in the instance. + * + */ +bool zhuyin_guess_sentence(zhuyin_instance_t * instance); + +/** + * zhuyin_guess_sentence_with_prefix: + * @instance: the zhuyin instance. + * @prefix: the prefix before the sentence. + * @returns: whether the sentence are guessed successfully. + * + * Guess a sentence from the saved pinyin keys with a prefix. + * + */ +bool zhuyin_guess_sentence_with_prefix(zhuyin_instance_t * instance, + const char * prefix); + +/** + * zhuyin_phrase_segment: + * @instance: the zhuyin instance. + * @sentence: the utf-8 sentence to be segmented. + * @returns: whether the sentence are segmented successfully. + * + * Segment a sentence and saved the result in the instance. + * + */ +bool zhuyin_phrase_segment(zhuyin_instance_t * instance, + const char * sentence); + +/** + * zhuyin_get_sentence: + * @instance: the zhuyin instance. + * @sentence: the saved sentence in the instance. + * @returns: whether the sentence is already saved in the instance. + * + * Get the sentence from the instance. + * + * Note: the returned sentence should be freed by g_free(). + * + */ +bool zhuyin_get_sentence(zhuyin_instance_t * instance, + char ** sentence); + +/** + * zhuyin_parse_full_pinyin: + * @instance: the zhuyin instance. + * @onepinyin: a single full pinyin to be parsed. + * @onekey: the parsed key. + * @returns: whether the parse is successfully. + * + * Parse a single full pinyin. + * + */ +bool zhuyin_parse_full_pinyin(zhuyin_instance_t * instance, + const char * onepinyin, + ChewingKey * onekey); + +/** + * zhuyin_parse_more_full_pinyins: + * @instance: the zhuyin instance. + * @pinyins: the full pinyins to be parsed. + * @returns: the parsed length of the full pinyins. + * + * Parse multiple full pinyins and save it in the instance. + * + */ +size_t zhuyin_parse_more_full_pinyins(zhuyin_instance_t * instance, + const char * pinyins); + +/** + * zhuyin_parse_chewing: + * @instance: the zhuyin instance. + * @onechewing: the single chewing to be parsed. + * @onekey: the parsed key. + * @returns: whether the parse is successfully. + * + * Parse a single chewing. + * + */ +bool zhuyin_parse_chewing(zhuyin_instance_t * instance, + const char * onechewing, + ChewingKey * onekey); + +/** + * zhuyin_parse_more_chewings: + * @instance: the zhuyin instance. + * @chewings: the chewings to be parsed. + * @returns: the parsed length of the chewings. + * + * Parse multiple chewings and save it in the instance. + * + */ +size_t zhuyin_parse_more_chewings(zhuyin_instance_t * instance, + const char * chewings); + +/** + * zhuyin_valid_zhuyin_keys: + * @instance: the zhuyin instance. + * @returns: whether all zhuyin keys are valid. + * + * Valid parsed zhuyin keys, if all valid, return true; + * if not, modify raw user input and return false. + * + */ +bool zhuyin_valid_zhuyin_keys(zhuyin_instance_t * instance); + +/** + * zhuyin_get_parsed_input_length: + * @instance: the zhuyin instance. + * @returns: the parsed_length of the input. + * + * Get the parsed length of the input. + * + */ +size_t zhuyin_get_parsed_input_length(zhuyin_instance_t * instance); + + +/** + * zhuyin_in_chewing_keyboard: + * @instance: the zhuyin instance. + * @key: the input key. + * @symbols: the chewing symbols must be freed by g_strfreev. + * @returns: whether the key is in current chewing scheme. + * + * Check whether the input key is in current chewing scheme. + * + */ +bool zhuyin_in_chewing_keyboard(zhuyin_instance_t * instance, + const char key, gchar *** symbols); +/** + * zhuyin_guess_candidates_after_cursor: + * @instance: the zhuyin instance. + * @offset: the offset in the pinyin keys. + * @returns: whether a list of tokens are gotten. + * + * Guess the candidates at the offset. + * + */ +bool zhuyin_guess_candidates_after_cursor(zhuyin_instance_t * instance, + size_t offset); + +/** + * zhuyin_guess_candidates_before_cursor: + * @instance: the zhuyin instance. + * @offset: the offset in the pinyin keys. + * @returns: whether a list of tokens are gotten. + * + * Guess the candidates at the offset. + * + */ +bool zhuyin_guess_candidates_before_cursor(zhuyin_instance_t * instance, + size_t offset); + +/** + * zhuyin_choose_candidate: + * @instance: the zhuyin instance. + * @offset: the offset in the pinyin keys. + * @candidate: the selected candidate. + * @returns: the cursor after the chosen candidate. + * + * Choose a full pinyin candidate at the offset. + * + */ +int zhuyin_choose_candidate(zhuyin_instance_t * instance, + size_t offset, + lookup_candidate_t * candidate); + +/** +* zhuyin_clear_constraint: +* @instance: the zhuyin instance. +* @offset: the offset in the pinyin keys. +* @returns: whether the constraint is cleared. +* +* Clear the previous chosen candidate. +* +*/ +bool zhuyin_clear_constraint(zhuyin_instance_t * instance, + size_t offset); + +/** + * zhuyin_lookup_tokens: + * @instance: the zhuyin instance. + * @phrase: the phrase to be looked up. + * @tokenarray: the returned GArray of tokens. + * @returns: whether the lookup operation is successful. + * + * Lookup the tokens for the phrase utf8 string. + * + */ +bool zhuyin_lookup_tokens(zhuyin_instance_t * instance, + const char * phrase, GArray * tokenarray); + +/** + * zhuyin_train: + * @instance: the zhuyin instance. + * @returns: whether the sentence is trained. + * + * Train the current user input sentence. + * + */ +bool zhuyin_train(zhuyin_instance_t * instance); + +/** + * zhuyin_reset: + * @instance: the zhuyin instance. + * @returns: whether the zhuyin instance is resetted. + * + * Reset the zhuyin instance. + * + */ +bool zhuyin_reset(zhuyin_instance_t * instance); + +/** + * zhuyin_get_bopomofo_string: + * @instance: the zhuyin instance. + * @key: the chewing key. + * @utf8_str: the chewing string. + * @returns: whether the get operation is successful. + * + * Get the chewing string of the key. + * + */ +bool zhuyin_get_bopomofo_string(zhuyin_instance_t * instance, + ChewingKey * key, + gchar ** utf8_str); + +/** + * zhuyin_get_pinyin_string: + * @instance: the zhuyin instance. + * @key: the pinyin key. + * @utf8_str: the pinyin string. + * @returns: whether the get operation is successful. + * + * Get the pinyin string of the key. + * + */ +bool zhuyin_get_pinyin_string(zhuyin_instance_t * instance, + ChewingKey * key, + gchar ** utf8_str); + +/** + * zhuyin_token_get_phrase: + * @instance: the zhuyin instance. + * @token: the phrase token. + * @len: the phrase length. + * @utf8_str: the phrase string. + * @returns: whether the get operation is successful. + * + * Get the phrase length and utf8 string. + * + */ +bool zhuyin_token_get_phrase(zhuyin_instance_t * instance, + phrase_token_t token, + guint * len, + gchar ** utf8_str); + +/** + * zhuyin_token_get_n_pronunciation: + * @instance: the zhuyin instance. + * @token: the phrase token. + * @num: the number of pinyins. + * @returns: whether the get operation is successful. + * + * Get the number of the pinyins. + * + */ +bool zhuyin_token_get_n_pronunciation(zhuyin_instance_t * instance, + phrase_token_t token, + guint * num); + +/** + * zhuyin_token_get_nth_pronunciation: + * @instance: the zhuyin instance. + * @token: the phrase token. + * @nth: the index of the pinyin. + * @keys: the GArray of chewing key. + * @returns: whether the get operation is successful. + * + * Get the nth pinyin from the phrase. + * + */ +bool zhuyin_token_get_nth_pronunciation(zhuyin_instance_t * instance, + phrase_token_t token, + guint nth, + ChewingKeyVector keys); + +/** + * zhuyin_token_get_unigram_frequency: + * @instance: the zhuyin instance. + * @token: the phrase token. + * @freq: the unigram frequency of the phrase. + * @returns: whether the get operation is successful. + * + * Get the unigram frequency of the phrase. + * + */ +bool zhuyin_token_get_unigram_frequency(zhuyin_instance_t * instance, + phrase_token_t token, + guint * freq); + +/** + * zhuyin_token_add_unigram_frequency: + * @instance: the zhuyin instance. + * @token: the phrase token. + * @delta: the delta of the unigram frequency. + * @returns: whether the add operation is successful. + * + * Add delta to the unigram frequency of the phrase token. + * + */ +bool zhuyin_token_add_unigram_frequency(zhuyin_instance_t * instance, + phrase_token_t token, + guint delta); + +/** + * zhuyin_get_n_candidate: + * @instance: the zhuyin instance. + * @num: the number of the candidates. + * @returns: whether the get operation is successful. + * + * Get the number of the candidates. + * + */ +bool zhuyin_get_n_candidate(zhuyin_instance_t * instance, + guint * num); + +/** + * zhuyin_get_candidate: + * @instance: the zhuyin instance. + * @index: the index of the candidate. + * @candidate: the retrieved candidate. + * + * Get the candidate of the index from the candidates. + * + */ +bool zhuyin_get_candidate(zhuyin_instance_t * instance, + guint index, + lookup_candidate_t ** candidate); + +/** + * zhuyin_get_candidate_type: + * @instance: the zhuyin instance. + * @candidate: the lookup candidate. + * @type: the type of the candidate. + * @returns: whether the get operation is successful. + * + * Get the type of the lookup candidate. + * + */ +bool zhuyin_get_candidate_type(zhuyin_instance_t * instance, + lookup_candidate_t * candidate, + lookup_candidate_type_t * type); + +/** + * zhuyin_get_candidate_string: + * @instance: the zhuyin instance. + * @candidate: the lookup candidate. + * @utf8_str: the string of the candidate. + * @returns: whether the get operation is successful. + * + * Get the string of the candidate. + * + */ +bool zhuyin_get_candidate_string(zhuyin_instance_t * instance, + lookup_candidate_t * candidate, + const gchar ** utf8_str); + +/** + * zhuyin_get_n_zhuyin: + * @instance: the zhuyin instance. + * @num: the number of the pinyins. + * @returns: whether the get operation is successful. + * + * Get the number of the pinyins. + * + */ +bool zhuyin_get_n_zhuyin(zhuyin_instance_t * instance, + guint * num); + +/** + * zhuyin_get_zhuyin_key: + * @instance: the zhuyin instance. + * @index: the index of the pinyin key. + * @key: the retrieved pinyin key. + * @returns: whether the get operation is successful. + * + * Get the pinyin key of the index from the pinyin keys. + * + */ +bool zhuyin_get_zhuyin_key(zhuyin_instance_t * instance, + guint index, + ChewingKey ** key); + +/** + * zhuyin_get_zhuyin_key_rest: + * @instance: the pinyin index. + * @index: the index of the pinyin key rest. + * @key_rest: the retrieved pinyin key rest. + * @returns: whether the get operation is successful. + * + * Get the pinyin key rest of the index from the pinyin key rests. + * + */ +bool zhuyin_get_zhuyin_key_rest(zhuyin_instance_t * instance, + guint index, + ChewingKeyRest ** key_rest); + +/** + * zhuyin_get_zhuyin_key_rest_positions: + * @instance: the zhuyin instance. + * @key_rest: the pinyin key rest. + * @begin: the begin position of the corresponding pinyin key. + * @end: the end position of the corresponding pinyin key. + * @returns: whether the get operation is successful. + * + * Get the positions of the pinyin key rest. + * + */ +bool zhuyin_get_zhuyin_key_rest_positions(zhuyin_instance_t * instance, + ChewingKeyRest * key_rest, + guint16 * begin, guint16 * end); + +/** + * zhuyin_get_zhuyin_key_rest_length: + * @instance: the zhuyin instance. + * @key_rest: the pinyin key rest. + * @length: the length of the corresponding pinyin key. + * @returns: whether the get operation is successful. + * + * Get the length of the corresponding zhuyin key. + * + */ +bool zhuyin_get_zhuyin_key_rest_length(zhuyin_instance_t * instance, + ChewingKeyRest * key_rest, + guint16 * length); + +/** + * zhuyin_get_zhuyin_key_rest_offset: + * @instance: the zhuyin instance. + * @cursor: the cursor. + * @offset: the offset in the zhuyin array. + * @returns: whether the get operation is successful. + * + * Get the offset in the zhuyin key array. + * + */ +bool zhuyin_get_zhuyin_key_rest_offset(zhuyin_instance_t * instance, + guint16 cursor, + guint16 * offset); + +/** + * zhuyin_get_raw_user_input: + * @instance: the zhuyin instance. + * @utf8_str: the modified raw full pinyin after choose candidate. + * @returns: whether the get operation is successful. + * + * Get the modified raw full pinyin after choose candidate. + * + */ +bool zhuyin_get_raw_user_input(zhuyin_instance_t * instance, + const gchar ** utf8_str); + +/** + * zhuyin_get_n_phrase: + * @instance: the zhuyin instance. + * @num: the number of the phrase tokens. + * @returns: whether the get operation is successful. + * + * Get the number of the phrase tokens. + * + */ +bool zhuyin_get_n_phrase(zhuyin_instance_t * instance, + guint * num); + +/** + * zhuyin_get_phrase_token: + * @instance: the zhuyin instance. + * @index: the index of the phrase token. + * @token: the retrieved phrase token. + * @returns: whether the get operation is successful. + * + * Get the phrase token of the index from the phrase tokens. + * + */ +bool zhuyin_get_phrase_token(zhuyin_instance_t * instance, + guint index, + phrase_token_t * token); + +/* hack here. */ +typedef ChewingKey PinyinKey; +typedef ChewingKeyRest PinyinKeyPos; +typedef pinyin_option_t zhuyin_option_t; + + +G_END_DECLS + +#endif |