Beispiel #1
0
        /// <summary>
        /// Performs string auto completing. Instead of strings it returns node at the en of matching sequence.
        /// </summary>
        /// <param name="matching">The matching.</param>
        /// <param name="rules">The rules.</param>
        /// <returns></returns>
        public List <KeyValuePair <float, StringTreeNode> > AutoComplete([NotEmpty] string matching, [NotNull] StringMatchingRules rules)
        {
            List <KeyValuePair <float, StringTreeNode> > result = new List <KeyValuePair <float, StringTreeNode> >();

            for (int i = 0; i < root.children.Count; i++)
            {
                root.children[i].AutoComplete(matching, 0, rules.InitialScore, rules, result);
            }

            return(result);
        }
Beispiel #2
0
        /// <summary>
        /// Matches the specified STR.
        /// </summary>
        /// <param name="str">The STR.</param>
        /// <param name="position">The position.</param>
        /// <param name="score">The score.</param>
        /// <param name="rules">The rules.</param>
        /// <param name="result">The result.</param>
        internal protected void Match(string str, int position, float score, StringMatchingRules rules, List <KeyValuePair <float, string> > result)
        {
            // If cannot procceed, return.
            if (score < rules.MinScoreFilter)
            {
                return;
            }

            // This is special case if appending.
            if (str.Length == position)
            {
                // We decrement the score.
                score -= rules.CharMissingPenaltyAtEnd;
                if (score < rules.MinScoreFilter)
                {
                    return;
                }

                // We do the search.
                if (internalString != string.Empty)
                {
                    result.Add(new KeyValuePair <float, string>(score, internalString));
                }

                // We now expand to all children.
                for (int i = 0; i < children.Count; i++)
                {
                    children[i].Match(str, position, score, rules, result);
                }

                return;
            }

            // We first check if matched.
            if (str[position] == character)
            {
                // We check if we can match against internal string.
                if (internalString != string.Empty)
                {
                    float xscore = score - rules.CharIgnorePenalty * (str.Length - position - 1);
                    if (xscore >= rules.MinScoreFilter)
                    {
                        result.Add(new KeyValuePair <float, string>(score, internalString));
                    }
                }

                // We proceed matching
                for (int i = 0; i < children.Count; i++)
                {
                    children[i].Match(str, position + 1, score, rules, result);
                }
            }
            else if (char.ToLowerInvariant(str[position]) == char.ToLowerInvariant(character))
            {
                float xscore = score + rules.CharCaseMismatchPenalty;

                // We check if we have internal string.
                if (internalString != string.Empty)
                {
                    float xxscore = score - rules.CharIgnorePenalty * (str.Length - position - 1);
                    if (xxscore >= rules.MinScoreFilter)
                    {
                        result.Add(new KeyValuePair <float, string>(score, internalString));
                    }
                }

                // We proceed matching.
                for (int i = 0; i < children.Count; i++)
                {
                    children[i].Match(str, position + 1, xscore, rules, result);
                }
            }
            else
            {
                // Ignore character case.
                for (int i = 0; i < children.Count; i++)
                {
                    children[i].Match(str, position, score - rules.CharIgnorePenalty, rules, result);
                }

                // Insert character case.
                for (int j = 0; j < children.Count; j++)
                {
                    children[j].Match(str, position + 1, score - rules.CharMissingPenalty, rules, result);
                }
            }
        }
Beispiel #3
0
        /// <summary>
        /// We do a search using supplied rules.
        /// </summary>
        /// <param name="matching"></param>
        /// <param name="rules"></param>
        public List <KeyValuePair <float, string> > Search([NotEmpty] string matching, [NotNull] StringMatchingRules rules)
        {
            // We start the progress.
            List <KeyValuePair <float, string> > result = new List <KeyValuePair <float, string> >();

            for (int i = 0; i < root.children.Count; i++)
            {
                root.children[i].Match(matching, 0, rules.InitialScore, rules, result);
            }

            // We return the result.
            return(result);
        }
Beispiel #4
0
        /// <summary>
        /// Auto completes the string.
        /// </summary>
        /// <param name="str">The STR.</param>
        /// <param name="position">The position.</param>
        /// <param name="score">The score.</param>
        /// <param name="rules">The rules.</param>
        /// <param name="result">The result.</param>
        internal protected void AutoComplete(string str, int position, float score,
                                             StringMatchingRules rules, List <KeyValuePair <float, StringTreeNode> > result)
        {
            // If cannot procceed, return.
            if (score < rules.MinScoreFilter)
            {
                return;
            }

            // Check if last character.
            if (position + 1 == str.Length)
            {
                result.Add(new KeyValuePair <float, StringTreeNode>(score, this));
                return;
            }

            // We first check if matched.
            if (str[position] == character)
            {
                // We check if we can match against internal string.
                if (internalString != string.Empty)
                {
                    float xscore = score - rules.CharIgnorePenalty * (str.Length - position - 1);
                    if (xscore >= rules.MinScoreFilter)
                    {
                        result.Add(new KeyValuePair <float, StringTreeNode>(score, this));
                    }
                }

                // We proceed matching
                for (int i = 0; i < children.Count; i++)
                {
                    children[i].AutoComplete(str, position + 1, score, rules, result);
                }
            }
            else if (char.ToLowerInvariant(str[position]) == char.ToLowerInvariant(character))
            {
                float xscore = score + rules.CharCaseMismatchPenalty;

                // We check if we have internal string.
                if (internalString != string.Empty)
                {
                    float xxscore = score - rules.CharIgnorePenalty * (str.Length - position - 1);
                    if (xxscore >= rules.MinScoreFilter)
                    {
                        result.Add(new KeyValuePair <float, StringTreeNode>(score, this));
                    }
                }

                // We proceed matching.
                for (int i = 0; i < children.Count; i++)
                {
                    children[i].AutoComplete(str, position + 1, xscore, rules, result);
                }
            }
            else
            {
                // Ignore character case.
                for (int i = 0; i < children.Count; i++)
                {
                    children[i].AutoComplete(str, position, score - rules.CharIgnorePenalty, rules, result);
                }


                // Insert character case.
                for (int j = 0; j < children.Count; j++)
                {
                    children[j].AutoComplete(str, position + 1, score - rules.CharMissingPenalty, rules, result);
                }
            }
        }