/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2007 Sun Microsystems, Inc. All Rights Reserved.
 *
 * The contents of this file are subject to the terms of either the GNU Lesser
 * General Public License Version 2.1 only ("LGPL") or the Common Development and
 * Distribution License ("CDDL")(collectively, the "License"). You may not use this
 * file except in compliance with the License. You can obtain a copy of the CDDL at
 * http://www.opensource.org/licenses/cddl1.php and a copy of the LGPLv2.1 at
 * http://www.opensource.org/licenses/lgpl-license.php. See the License for the
 * specific language governing permissions and limitations under the License. When
 * distributing the software, include this License Header Notice in each file and
 * include the full text of the License in the License file as well as the
 * following notice:
 *
 * NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION LICENSE
 * (CDDL)
 * For Covered Software in this distribution, this License shall be governed by the
 * laws of the State of California (excluding conflict-of-law provisions).
 * Any litigation relating to this License shall be subject to the jurisdiction of
 * the Federal Courts of the Northern District of California and the state courts
 * of the State of California, with venue lying in Santa Clara County, California.
 *
 * Contributor(s):
 *
 * If you wish your version of this file to be governed by only the CDDL or only
 * the LGPL Version 2.1, indicate your decision by adding "[Contributor]" elects to
 * include this software in this distribution under the [CDDL or LGPL Version 2.1]
 * license." If you don't indicate a single choice of license, a recipient has the
 * option to distribute your version of this file under either the CDDL or the LGPL
 * Version 2.1, or to extend the choice of license to its licensees as provided
 * above. However, if you add LGPL Version 2.1 code and therefore, elected the LGPL
 * Version 2 license, then the option applies only if the new code is made subject
 * to such option by the copyright holder.
 */

#ifndef SUNPY_IMI_CONTEXT_H
#define SUNPY_IMI_CONTEXT_H

#include "portability.h"

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef DEBUG
    #ifdef HAVE_ASSERT_H
    #include <assert.h>
    #endif
#endif

#include <map>
#include <vector>
#include <list>
#include <math.h>

#include "imi_data.h"
#include "ic_history.h"

#define UNKNOWN_WORD_ID             0
#define OOV_WORD_ID                 69
#define SENTENCE_BREAKER_ID         10

struct TLongExpFloat {
public:
    TLongExpFloat(const TLongExpFloat& b) : m_base(b.m_base), m_exp(b.m_exp) { }

    TLongExpFloat(int exp = 0, double base=0.0) : m_base(base), m_exp(exp) { }

    TLongExpFloat(double d);

    TLongExpFloat
    operator* (const TLongExpFloat& b) const;

    TLongExpFloat
    operator/ (const TLongExpFloat& b) const;

    bool
    operator< (const TLongExpFloat& b) const;

    bool
    operator<=(const TLongExpFloat& b) const;

    bool
    operator==(const TLongExpFloat& b) const;

    void
    toString(std::string& str) const;

    void
    toString(char* buf) const
    { if (buf) sprintf(buf, "%10lf*2^%d", m_base, m_exp); }

    double
    log2() const
    {
        #ifdef DEBUG
            //assert(m_base > 0.0);
        #endif
        return ::log2(m_base)+m_exp;
    }

private:
    double   m_base;
    int      m_exp;
};

/**
* TSentenceScore is only used for whole sentence score,
* the score from language model still using double.
*/
#ifdef _USE_RAW_PROBABILITY
    typedef TLongExpFloat           TSentenceScore;
#else
    typedef double                  TSentenceScore;
#endif

class CBone;
class CCandidate;

typedef std::list<CBone>            CSkeleton;
typedef CSkeleton::iterator         CSkeletonIter;
typedef std::vector<CCandidate>     CCandidates;
typedef CCandidates::iterator       CCandidatesIter;

class CIMIContext;
class CBoneInnerData;

union TCandiRank {
public:
    bool
    operator< (const TCandiRank& b) const
        { return m_all < b.m_all; };

    TCandiRank() : m_all(0) { }

    TCandiRank(bool user, bool best, unsigned int len,
               bool fromLattice, TSentenceScore score);

    TCandiRank(bool user, bool best, unsigned int len,
              bool fromLattice, unsigned score);

protected:
    unsigned  int               m_all;
    #if !defined(WORDS_BIGENDIAN)
    struct TAnony {
        unsigned                m_cost   : 24;
        unsigned                m_lattice: 1;
        unsigned                m_best   : 1;
        unsigned                m_len    : 5;
        unsigned                m_user   : 1;
    } anony;
    #else
    struct TAnony {
        unsigned                m_user   : 1;
        unsigned                m_len    : 5;
        unsigned                m_best   : 1;
        unsigned                m_lattice: 1;
        unsigned                m_cost   : 24;
    } anony;
    #endif

};

/**
 * CCandidate represent basic information about a single candidate.
 * Its start bone and finishing bone. It's content string. and its
 * word id.
 */
class CCandidate {
public:
    friend class CIMIContext;
public:
    CSkeletonIter                   m_BoneStart;
    CSkeletonIter                   m_BoneEnd;
    const TWCHAR                   *m_String;

public:
    CCandidate(const CCandidate& b)
        : m_BoneStart(b.m_BoneStart), m_BoneEnd(b.m_BoneEnd),
          m_String(b.m_String), m_WordId(b.m_WordId) { }

    /** Give out the constructor for convinience */
    CCandidate(const TWCHAR* s = NULL,
               CSkeletonIter h=CSkeletonIter(),
               CSkeletonIter t=CSkeletonIter(),
               unsigned int wid=0)
        : m_BoneStart(h), m_BoneEnd(t), m_String(s), m_WordId(wid) { }

    void
    print(std::string& prefix);

protected:
    unsigned int                      m_WordId;
}; // of CCandidate


/**
 * Bone is the basic unit for CIMSessionDate to store a Syllable, ie
 * a Pinyin string for only one Chinese character. Such as "zhang",
 * or "zh" under non-complete pinyin.
 */
class CBone {
    friend class CIMIContext;
public:
    /**
     * In case that use input is not Pinyin, such as under English input
     * mode, A bone contains a string for the input. For English, all
     * consecutive string grouped into one bone, such as "SUN Microsystem";
     * For Punc, each punctuaction become on bone, such as ": would be
     * split into two bones.
     *
     * For Pinyin type, there are three different type definition, and the
     * value for each syllable string depends on whether or not NonComplete
     * Pinyin mode is enabled:
     *
     * NODE_PINYIN           : Valid pinyin. Such as "zh" with NonComplet
     *                         Pinyin enabled, or "zhang" \n
     * NODE_INVALID_PINYIN   : Invalid syllable string, such as "u"; or "afdasf"\n
     * NODE_INCOMPLETE_PINYIN: incomplete syllable string (maybe complet further),
     *                         such as "to"; or "zh" when NonComplete Pinyin disabled.
     */
    enum NODE_TYPE {
       NODE_TAIL                = 0x0000,      //pusedo tail node

       CATE_PINYIN              = 0x0100,
       NODE_PINYIN              = 0x0101,      //pinyin
       NODE_INVALID_PINYIN      = 0x0102,      //invalid syllable string
       NODE_INCOMPLETE_PINYIN   = 0x0103,      //incomplete syllable string


       CATE_OTHER               = 0x0200,
       NODE_ASCII               = 0x0201,      //english string
       NODE_PUNC                = 0x0202,      //punctuation
       NODE_SIMBOL              = 0x0203,      //other simbol
       NODE_DIGITAL             = 0x0204       //not implemeted here

    }; // of NODE_TYPE

    /**
     * Boundary type indicate how the bone is seperated, by (1) Automatic
     * Syllable segmentation, (2) different bone type or punc bone seperate
     * rule, (3) user sepecified.
     */
    enum BOUNDARY_TYPE {
       AUTO_BOUNDARY,               //automatic segmentation result
       ABSOLUTE_BOUNDARY,           //boundary without ambiguation
       USER_BOUNDARY               //user given boundary
    }; // of BOUNDARY_TYPE

public:
    int                             m_BoneType;
    int                             m_BoundaryType;   // original code for m_String[0] in non_pinyin node
    wstring                         m_String;

public:
    /**
     * Never copy or allocate space for m_pInnerData;
     */
    CBone(const CBone& b);

    /**
     * @param boundType: Boundary type.
     * @param boneType: BoneType.
     * No space is allocated for m_pInnerData
     */
    CBone(int boundType = AUTO_BOUNDARY, int boneType = NODE_TAIL);

    /**
     * @param pwc  can not be NULL
     * @param boundType: Boundary type.
     * @param boneType: BoneType.
     * No space is allocated for m_pInnerData
     */
    CBone(const TWCHAR* pwc, int boundType = AUTO_BOUNDARY, int boneType = NODE_TAIL);

    /**
     * @param pwc  the string should be copied into this bone, not NULL
     * @param len  the string len
     * @param boundType: Boundary type.
     * @param boneType: BoneType.
     * No space is allocated for m_pInnerData
     */
    CBone(const TWCHAR* pwc, size_t len, int boundType, int boneType);

    /** Free all space if necessary. */
    ~CBone();

    inline bool
    isPinyinNode() const
        { return ((m_BoneType & CATE_PINYIN)!= 0); }

    inline bool
    isValidPinyinNode() const
        { return (m_BoneType == NODE_PINYIN || m_BoneType == NODE_INCOMPLETE_PINYIN); }

    inline bool
    isUserBoundary() const
        { return m_BoundaryType == USER_BOUNDARY; }

    inline bool
    isAutoBoundary() const
        { return m_BoundaryType == AUTO_BOUNDARY; }

    inline bool
    isTailNode() const
        { return (m_BoneType == 0); }

    bool
    isUserSelectionStart(void);

    void
    print(std::string& prefix);

protected:
    CBoneInnerData                 *m_pInnerData;
}; // of CBone


/**
 * It is more suitable to call this as Input Context together with I
 * MSessionView. These data record
 * input history for a input session. Normally a seesion data would
 * only contains history keys and the cursor position. It would be enough
 * to find corresponding result from the history for most IME.
 *
 * The Session data class here take responsible for generating best sentence
 * from Pinyin string. It also contains all core algorithm for this conversion
 * progress.
 *
 * All Key processing job should be done by Session View class, and only several
 * interface exist here for the SessionView to modify Input Context and get
 * best sentence and ranked candidates.
 *
 * The other important function it provide is Automatic Pinyin segmentation.
 *
 * For our input method, from the aspect of effeciency, a internal
 * search lattice should also be remained and only partial of the lattice
 * would be rebuild or updated when user give a new input. The reason is
 * that it is time consuming to construct a whole search lattice, especially
 * for a long sentence and/or with Non-Complete syllables, which cause
 * potential candidates number increase. Yet all search related data are
 * hidden to outer usage.
 */
class CIMIContext {
public:
    /*@{*/
    /**
     * Constructor of CIMIContext. Set all the pointer to NULL.
     * set Non-Complete Syllable to true, set Strict Left2Right Model
     * to false.
     *
     * Note: At this time, CIMIContext could not be used to
     *       search directly. Only after setCoreData() and clear(),
     *       the internal search lattice are constructed and can
     *       be used.
     */
    CIMIContext();

    /**
     * free all resource/spaces
     */
    virtual
    ~CIMIContext()
        { m_Skeleton.clear(); }
    /*@}*/

    /*@{*/
    /**
     * Copy language model ptr and Pinyin-Trie Ptr inside the IMCoreData
     * into my own member.
     * Also build Chinese Punctuation Map from Pinyin-Trie.
     *
     * @param pCoreData is the core resource data for the Input Method
     */
    void
    setCoreData(CIMIData *pCoreData);

    /**
     * clear all internal Input Context, after this call, the Session data
     * or Input Context should same as they were just created. (Of cause,
     * the values from core data and desktop data remains.) More specifically,
     * it will clear skeleton, add a psuedo tail node, set internal candidate
     * position to skeleton.end() (which means no candidates needed now). then
     * it will construct a initial search lattice.
     *
     * Note: This function should be called only after setCoreData, because
     *       it will use the language model to construct a empty search
     *       lattice.
     */
    void
    clear();

    void
    setHistoryMemory(CICHistory *phm);

    CICHistory *
    getHistoryMemory();

    /** return true if defined DEBUG */
    void
    print_lattice();

    //memorize sentence in current text
    void
    memorize(void);

    /**
     * Return the bone list to let the view read them directly.
     */
    CSkeleton &
    getSkeleton(void)
        { return m_Skeleton; }

    /**
     * To construct the lattice, algorithm need to append two
     * psuedo tail bone at the end of the bone list.
     * For the SessionView could operate the list as the two tailing
     * bone were not there, SessionView should call this function
     * to replace call like getSekelton()->end() when iterating the
     * Skeleton (bone list).
     *
     * @return the first psuedo tailing node at the end of bone
     *     list. For SessionView usage.
     */
    CSkeletonIter
    getLastBone(void)
        { return --(--(m_Skeleton.end())); }

    /**
    * To cooperate with the getLastBone.
    * @return the first bone of the skeleton
    */
    CSkeletonIter
    getFirstBone(void)
        { return m_Skeleton.begin(); }

    bool
    isEmpty(void)
        { return m_Skeleton.size() == 2; }
    /*@}*/


    // functions to set options. Options should be set when Session Data
    // is clear, ie, just created or just after clear() is called

    /*@{*/
    /**
     * NonCompleteSyllable means we can give a candidates when PinYin is
     * just partial a complete syllable string. Such as "sh" would give
     * all characters with one of it PinYin starts from "sh", ex, "shi",
     * "sheng" etc.
     * In our definition, Non-Complete PinYin not only limitied on "SHENGMU",
     * For examplet, "to" is not a valid full pinyin, yet it could lead
     * "tong", "tou". So it would also gives out those corresponding
     * characters.
     * On the other hand, when a PinYin String is a valid Full Syllable
     * PinYin, even it could lead other Full Syllable PinYin, it will
     * not be treated as non-complete PinYin. For example, "da" will only
     * give candidates characters pronounced "da", although it could lead
     * "dan" "dao" "dang", etc.
     */
    void
    setNonCompleteSyllable(bool use = true)
        { m_bNonCompleteSyllable = use; }

    bool
    canNonCompleteSyllable()
        { return m_bNonCompleteSyllable; }

    /**
     * Left2RightSelection could improve the performance under
     * the TwoLine view style. But could not be used with OneLine view
     * style and ThreeLine view style.
     */
    void
    setLeft2RightSelection(bool use = true)
        { m_bStrictLeft2Right = use; }

    bool
    isGBKEnabled()
        { return m_bGBK; }

    void
    enableGBK(bool enable)
        { m_bGBK = enable; }

    void
    setHistoryPower(int power)
        { m_HistoryPower = ((power>= 0 && power <=10)?(power):(3)); }

    int
    getHistoryPower()
        { return m_HistoryPower; }

    void
    enableContextRanking(bool enable)
        { m_ContextRanking = enable; }

    int
    isContextRankingEnabled()
        { return m_ContextRanking; }
    /*@}*/

    /*@{*/
    bool
    isValidSyllable(const wstring& sy)
        { return isValidSyllable(sy.c_str()); }

    bool
    isValidSyllable(const TWCHAR* pstr);

    /**
     * segPinyinSimplest() do simplest segmentation for given PinYin. That, the
     * last char is the just input by user (or just delete by user), and
     * prefix string is at least non-complet syllable. This kind of segment
     * suitable for OneLineView. Syllable Pinyin string can only be modified
     * at the end.
     *
     * @param pinyin : a wide char string. Each char in the string should only
     * be one of the following: [a-z]. Note, that prefix string (except the
     * last char should already be complete or non-complet).
     *
     * @param result: After segmentation, result contains sequence of syllable
     * Bones. The result may be one of the following status:\n
     *   (1) two bones, the first is complete, and
     *                  the second is complete or non-complete.\n
     *   (2) two bones, the first is complete, and
     *                  the second is invalid.\n
     *   (3) single complete or non-complet bone, with AUTO_BOUNDARY.\n
     *   (4) single invalid bone.\n
     * Status (2) and (4) is invalid, program should reject the last
     * input char. Status (1)  program should commit the first bone and
     * use the remaining string as prefix. For status (3), program
     * should wait for further input.
     *
     * @return whether the segmentation is valid(or whether the last char
     * is valid)
     */
    bool
    segPinyinSimplest(const wstring& pinyin, CSkeleton& result);

    /**
    * [head1, tail1) [head2, tail2) may from two link. and form an virtual link.
    * generate the segmentation result into result where each node represent a
    * syllable. Note that invalid_syllable is inevitable.
    */
    void
    segPinyin(CSkeletonIter head1, CSkeletonIter tail1,
              CSkeletonIter head2, CSkeletonIter tail2,
              CSkeleton& result);
    /*@}*/

    /*@{*/
    /**
     * modify skeleton. remove bones [boneStart, boneEnd). and insert all
     * bones in the skel just before the boneEnd. Then update the
     * search lattice and search for a new result.
     *
     * @param boneStart    start bone iterator in the skeleton
     * @param boneEnd      ending bone iterator in the skeleton
     * @param skel         the new list of bones to be inserted.
     * @param pItLeftmost  the leftmost bone affected by the operation.
     *                     for manual search
     *
     * @return  whether or not the original gotted candidates called
     *          by getCandidates() would be affected by this modification.
     * @retval true   Affected.  getCandidates() should be call again.
     * @retval false  Not affected.
     */
    bool
    modify(CSkeletonIter boneStart, CSkeletonIter boneEnd, CSkeleton& skel,
           bool doSearch=true, CSkeletonIter* pItLeftmost=NULL);

    /**
     * modify skeleton. remove bones [boneStart, boneEnd). and insert all
     * bones in the skel just before the boneEnd. Do Syllable segmentation
     * again to make syllables legal. This may look left for 2/3 nodes. Also
     * new cursor position are counted.
     * Then update the search lattice and search for a new result if needed.
     *
     * @param boneStart    start bone iterator in the skeleton
     * @param boneEnd      ending bone iterator in the skeleton
     * @param skel         the new list of bones to be inserted.
     * @param cursor       the cursor bone in the skel, after this function,
     *                     it contains the corresponding cursor bone iterator
     *                     in the IC's Skeleton.
     * @param cursorIdx    the cursor's idx inside the cursor bone. Also contain
     *                     new position index after this function.
     * @param candiStart   The candidate list's starting position. Also the leftmost
     *                     when looking left to prevent re-segment insufficient.
     *                     Return value are set to its new position, because it would
     *                     change onto the new list.
     * @param stickLeft    When the cursor position after segment is located at
     *                     boundary. This give how it should be, @value true for
     *                     the tail of the left bone, @value false for the head
     *                     of the right bone.
     * @param doSearch     should be always true, otherwise you have to research the
     *                     whole skeleton after this call, because currently we do
     *                     not provide an interface to return the righmost bone to
     *                     remember the minimized the research demand cause by this.
     * @return  whether or not the original gotted candidates called
     *          by getCandidates() would be affected by this modification.
     * @retval true   Affected.  getCandidates() should be call again.
     * @retval false  Not affected.
     */
    bool
    modifyAndReseg(CSkeletonIter boneStart, CSkeletonIter boneEnd, CSkeleton& skel,
                   CSkeletonIter& cursor, int& cursorIdx, CSkeletonIter& candiStart,
                   bool stickLeft=true, bool doSearch=true);


    /**
     * Cancel original selection that including the bone
     *
     * @param bone  Selection is a candidate, which have a bone range.
     *              If any selection's range contains the bone, it
     *              would be canceled.
     * @param update "true" to update the search lattice. Normally,
     *        when called by SessionView, update should be set. For
     *        internal call of the function, one could let the update
     *        parameter to false, and do lattice searching later.
     *
     * @return the Bone on the left of param bone, which is the start bone
     *         of a user selection, and the selection include param bone.
     *         if no such a bone found, just return param bone itself.
     *
     * The algorithm working like following:
     * - Find the left most bone whose PinYin lexicon state could arrived here.
     *   This could be done just read the first element of BoneInnerData's
     *   m_LexiconStates.
     * - From current bone to the left-most bone, try to find the first meet
     *   bone whose BestWord candidates is valid.
     *     -# if the BestWord's right bone is at the left of target bone:
     *        ====>do nothing
     *     -# if the BestWord's right bone is at the right of the target bone:
     *        ====> Invalidate the BestWord. And if update is set,
     *              ====> searchFrom the BestWord's right bone.
     */
    CSkeletonIter
    cancelSelection(CSkeletonIter bone, bool update=true);

    /**
     * Cancel original selection that including the bone, but do
     * not count User Selection right starting at bone.
     *
     * @param bone  Selection is a candidate, which have a bone range.
     *              If any selection's range contains the bone, it
     *              would be canceled.
     * @param update "true" to update the search lattice. Normally,
     *        when called by SessionView, update should be set. For
     *        internal call of the function, one could let the update
     *        parameter to false, and do lattice searching later.
     *
     * @return the Bone on the left of param bone, which is the start bone
     *         of a user selection, and the selection include param bone.
     *         if no such a bone found, just return param bone itself.
     */
    CSkeletonIter
    cancelSelectionCover(CSkeletonIter bone, bool update=true);


    /**
     * Tell me that user make a selection for a specific candidate.
     * The lattice will be updated (only the neccessary part). And
     * best sentence are searched.
     *
     * @param candi   the user selection.
     * @return whether or not it will affect the previous gotted
     *         candidate list.
     *
     * Algorithm-Description:
     *    - Put the candi to the candi's leftBone's bestWord, and validate it.
     *        -# If Pure Left to Right model enabled, then:
     *        ====> rebuild the lattice from bestWord's left bone.
     *        -# If Pure Left to Right model disabled, then
     *        ====> rebuild the lattice from bestWord's right bone.
     *        .
     *    .
     *
     *   the search function will deal with the human selection, the processing
     *   of selection focused on two different things:
     *    - the word-set finding
     *    - the word scoring
     *    .
     *    More specificlly, the search routine will, normally, finding candidates
     *    words bone after bone. At each bone:
     *    -# It first check all finishing lexicon states, ie., get all possible
     *       words that will ending right before this bone, using them to construct
     *       lattice states of this bone. For each word, there is a inner cost
     *       associated with them. (For future word class usage) This cost is
     *       positive double. But for user selection, the cost should will be
     *       set to a suitable negtive double to make the best path alway go
     *       throught this word. The value of the negetive is affected by:
     *       maximum word length, N-gram's N, mini-backoff weight, mini-common-pr.
     *       (Due to float plus operation accuracy lost, the value should not be
     *        set to a very negitive, although the less the better.) But when
     *       "Pure Left to Right" is enabled, this trick will not be used, on
     *       the other hand, the following step would make sure there is only
     *       one possible transfer/edge on the lattice.
     *    -# Then, from all possible lexicon states (plus a root state), let them
     *       transfer on this bone's PINYIN string. Put the result states after
     *       transfer on the next bone as Lexicon states. But when
     *       "Pure Left to Right" model enabled, and a user selection is
     *       meet at the starting bone, then:
     *        - clear all states inside the bestWord's range.
     *        - jump directly to the bestWord's right bone, with only one word,
     *          ie. the bestWord, transfer enabled in this range.
     *        - then search from the right bone
     *    .
     */
    bool
    makeSelection(const CCandidate& candi);
    /*@}*/

    /*@{*/
    /**
     * Get candidate list for position at the bone.
     *
     * @param bone:   iterator pointed to a unit in the bone list.
     * @param result: the candidate list. Each candidate has a starting
     *     bone, ending bone, and a corresponding string. Currently
     *     all starting bone is the "bone" parameter.
     *
     * Currently, it will only give candidates that are starting at
     * the parameter bone. Normally, the lattice wouldn't save all words'
     * transfer cost information. But some good transfer edge could give
     * us infomation. To achieve high efficiency, in this function, no
     * probabilities are re-get from language model. But, we use the
     * following information to rank the candidates:
     *    -# If some words starting at bone is selected by the user, or
     *       it is a best edge of the best sentence, it will be listed as
     *       first.
     *    -# The longer the word, the better
     *    -# if some words' transfer cost could be got from the lattice,
     *       they are better than those from lexicon only.
     *    -# Use information stored in lexicon (where words could ranked
     *       by unigram).
     */
    void
    getCandidates(CSkeletonIter bone, CCandidates& result);

    /**
     * Get the best sentence corresponding from boneStart to boneEnd
     * @param boneStart
     * @param boneEnd
     * @param result  the result string
     * @return: the number of words converted in the best sentence. ie. not
     *          count the non-pinyin node or invalid pinyin node
     */
    int
    getBestSentence(wstring& result, CSkeletonIter boneStart, CSkeletonIter boneEnd, bool original_format=false);
    /*@}*/

    void
    searchFrom(CSkeletonIter boneStart);

protected:
    CSkeleton                       m_Skeleton;
    CSkeletonIter                   m_EffectiveCandiBoneStart;
    CSkeletonIter                   m_EffectiveCandiBoneEnd;

    bool                            m_bNonCompleteSyllable;
    bool                            m_bStrictLeft2Right;
    bool                            m_bGBK;
    bool                            m_bGB18030;
    int                             m_HistoryPower;
    bool                            m_ContextRanking;

    CThreadSlm                     *m_pModel;
    CPinyinTrie                    *m_pPinyinTrie;

    CICHistory                     *m_pHistory;


private:
    void
    transferBetween(CSkeletonIter h, CSkeletonIter t, unsigned int id, double ic);

    void
    buildLatticeStates(CSkeletonIter bone);

    CSkeletonIter
    forwardOnePinyinBone(CSkeletonIter bone);

    CSkeletonIter
    forwardPuncBone(CSkeletonIter bone);

    CSkeletonIter
    forwardPinyinBone(CSkeletonIter bone);

    CSkeletonIter
    forwardNonPinyinBone(CSkeletonIter bone);

    CSkeletonIter
    forwardInvalidBone(CSkeletonIter bone);

    CSkeletonIter
    forwardTailBone(CSkeletonIter bone);

}; // of CIMIContext

#endif

Indexes created Fri Nov 27 21:39:02 UTC 2009

Terms of Use | Privacy | Trademarks | Copyright Policy | Site Guidelines | Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.