GetCoordType() public méthode

public GetCoordType ( int PartOfSpeechID, int CoordID ) : int
PartOfSpeechID int
CoordID int
Résultat int
GrammarEngine2 Class Documentation
Exemple #1
0
    public TokenTagsEnumerator(bool IsBoundaryToken, SolarixGrammarEngineNET.SyntaxTreeNode _token, SolarixGrammarEngineNET.GrammarEngine2 gren)
    {
        token = _token;
        list  = new List <TokenRecognizer>();


        int id_entry = token.GetEntryID();
        int id_class = gren.GetEntryClass(id_entry);

        // Подготовим список измерений и атрибутов.
        List <SolarixGrammarEngineNET.CoordPair> dims  = new List <SolarixGrammarEngineNET.CoordPair>();
        List <SolarixGrammarEngineNET.CoordPair> attrs = new List <SolarixGrammarEngineNET.CoordPair>();
        List <SolarixGrammarEngineNET.CoordPair> pairs = token.GetPairs();

        foreach (SolarixGrammarEngineNET.CoordPair p in pairs)
        {
            int t = gren.GetCoordType(id_class, p.CoordID);
            if (t == 0 || t == 2)
            {
                attrs.Add(p);
            }
            else if (t == 1)
            {
                dims.Add(p);
            }
        }

        // ------------------------------------------------------
        // Часть речи - самый общий случай
        // ------------------------------------------------------

        TokenRecognizer tr4 = new TokenRecognizer(id_class, -1);

        list.Add(tr4);

        List <TokenRecognizer> more_abstract = new List <TokenRecognizer>();

        more_abstract.Add(tr4);

        // ------------------------------------------------------
        // Часть речи и комбинации атрибутов
        // ------------------------------------------------------

        if (attrs.Count > 0)
        {
            List <TokenRecognizer> created_recognizers = new List <TokenRecognizer>();

            bool[] dim_bit = new bool[attrs.Count];
            for (int i = 0; i < attrs.Count; ++i)
            {
                dim_bit[i] = false;
            }

            while (true)
            {
                List <SolarixGrammarEngineNET.CoordPair> selected_pairs = new List <SolarixGrammarEngineNET.CoordPair>();
                for (int i = 0; i < attrs.Count; ++i)
                {
                    if (dim_bit[i])
                    {
                        selected_pairs.Add(attrs[i]);
                    }
                }

                if (selected_pairs.Count > 0)
                {
                    TokenRecognizer tr3 = new TokenRecognizer(id_class, -1, selected_pairs);
                    tr3.SetMoreAbstract(more_abstract);
                    list.Add(tr3);
                    created_recognizers.Add(tr3);
                }

                // Следующая комбинация
                int carry = 1;
                for (int ibit = dim_bit.Length - 1; ibit >= 0; --ibit)
                {
                    if (dim_bit[ibit] == false)
                    {
                        dim_bit[ibit] = true;
                        carry         = 0;
                        break;
                    }
                    else
                    {
                        dim_bit[ibit] = false;
                    }
                }

                if (carry == 1)
                {
                    break;
                }
            }

            more_abstract = created_recognizers;
        }


        // Лемма - только id словарной статьи. Это боее частный случай, чем указание части речи.
        TokenRecognizer tr2 = new TokenRecognizer(-1, id_entry);

        tr2.SetMoreAbstract(more_abstract);
        list.Add(tr2);
        more_abstract = new List <TokenRecognizer>();
        more_abstract.Add(tr2);


        if (dims.Count > 0)
        {
            List <TokenRecognizer> created_recognizers = new List <TokenRecognizer>();

            // -----------------------------------------------------------------------
            // Лемма (то есть id словарной статьи) и различные комбинации измерений.
            // -----------------------------------------------------------------------
            bool[] dim_bit = new bool[dims.Count];
            for (int i = 0; i < dims.Count; ++i)
            {
                dim_bit[i] = false;
            }

            while (true)
            {
                List <SolarixGrammarEngineNET.CoordPair> selected_pairs = new List <SolarixGrammarEngineNET.CoordPair>();
                for (int i = 0; i < dims.Count; ++i)
                {
                    if (dim_bit[i])
                    {
                        selected_pairs.Add(dims[i]);
                    }
                }

                if (selected_pairs.Count > 0)
                {
                    TokenRecognizer tr5 = new TokenRecognizer(-1, id_entry, selected_pairs);
                    tr5.SetMoreAbstract(more_abstract);
                    created_recognizers.Add(tr5);
                    list.Add(tr5);
                }

                // Следующая комбинация
                int carry = 1;
                for (int ibit = dim_bit.Length - 1; ibit >= 0; --ibit)
                {
                    if (dim_bit[ibit] == false)
                    {
                        dim_bit[ibit] = true;
                        carry         = 0;
                        break;
                    }
                    else
                    {
                        dim_bit[ibit] = false;
                    }
                }

                if (carry == 1)
                {
                    break;
                }
            }

            more_abstract = created_recognizers;
        }


        // ----------------------------------
        // Лексема - самый частный случай.
        // ----------------------------------

        /*
         * if( !IsBoundaryToken )
         * {
         * TokenRecognizer tr0 = new TokenRecognizer( token.GetWord() );
         * tr0.SetMoreAbstract( more_abstract );
         * list.Add( tr0 );
         * }
         */

        return;
    }