Ejemplo n.º 1
0
        //**********************************************************************************************
        // BuildSpecificRule
        //
        // Starting with a generic size char rule, and a word with identifiers (which also determines
        // the rule size to build), build the specific rule.
        // Example:
        // Rule:                Hello #001# -> #001#   , growleft empty, growright #002#
        // Varword:                   #004##005##006#
        // Output patterns:     Hello #004##005##006# -> #004##005##006#
        //**********************************************************************************************
        private static void BuildSpecificRule(GenericRule rule, string varWord, out string inputPattern, out string outputPattern)
        {
            int ruleSize = varWord.Length;

            int    nextId      = 900;
            string id          = CharGenericRules.GenerateId(nextId++);
            string inputIdWord = id;

            outputPattern = rule.Output.Replace(rule.Id1, id);

            // Grow the rule as needed
            for (int i = 2; i <= ruleSize; i++)
            {
                id          = CharGenericRules.GenerateId(nextId++);
                inputIdWord = inputIdWord + id;

                string growLeft  = rule.GrowToLeft.Replace(rule.Id2, id);
                string growRight = rule.GrowToRight.Replace(rule.Id2, id);

                outputPattern = growLeft + outputPattern + growRight;
            }

            outputPattern += rule.Ending;
            inputPattern   = rule.Input.Replace(rule.Id1, inputIdWord);
        }
Ejemplo n.º 2
0
        //*********************************************************************************************
        // GetRule
        //*********************************************************************************************
        private GenericRule GetRule(string patternInput)
        {
            GenericRule ruleFound = null;

            // Find a matching rule in the list of rules
            foreach (GenericRule rule in rules)
            {
                if (patternInput == rule.Input)
                {
                    ruleFound = rule;
                    break;
                }
            }

            return(ruleFound);
        }
Ejemplo n.º 3
0
        //**********************************************************************************************
        // SentenceMatchesPattern
        //
        // Verify whether a string matches the rule input string with factIDs inside.
        // With the twist of allowing rules of multiple word sizes.
        //**********************************************************************************************
        private static bool SentenceMatchesPattern(GenericRule rule, string inputText, bool useAllInput, out string varWord)
        {
            varWord = string.Empty;

            // If it has end of sentence character, take it out -we don't want it tied to the last word.
            string empty = rule.Ending;

            Syntax.RemoveEndCharIfPresent(ref inputText, ref empty, rule.Ending.Trim());

            Dictionary <string, char> seenIDs = new Dictionary <string, char>();

            // Separate all the strings into words
            string[] inputWords   = Syntax.GetWords(inputText);
            string[] patternWords = Syntax.GetWords(rule.Input);

            // Check the input sentences against the pattern
            // Not the same number of words in the line, not match -if we are supposed to use all input
            if (useAllInput && inputWords.Length != patternWords.Length)
            {
                return(false);
            }

            // Either way, the input has to be at least the size of the pattern
            if (inputWords.Length < patternWords.Length)
            {
                return(false);
            }

            bool match = true;

            for (int word = 0; word < patternWords.Length && match; word++)
            {
                // It is not a variable word, and it is not the same, not match
                if (!CharGenericRules.IsIdWord(patternWords[word]))
                {
                    if (inputWords[word] != patternWords[word])
                    {
                        match = false;
                    }
                }
                else
                {
                    // #####
                    // Is it a VARIABLE SIZE variable word?
                    if (patternWords[word] == rule.Id1)
                    {
                        varWord = inputWords[word];
                    }
                    else
                    {
                        // #####
                        // It is a variable word, check each of its characters
                        int p = 0;
                        for (int c = 0; c < inputWords[word].Length && match; c++)
                        {
                            string id = CharGenericRules.ExtractIdOrChar(patternWords[word], p);

                            if (id.Length == 0)
                            {
                                // We ran out of pattern!!
                                match = false;
                            }
                            else if (id.Length == 1)
                            {
                                // Not really an ID! Must match the input
                                if (inputWords[word][c] != id[0])
                                {
                                    match = false;
                                }
                            }
                            else
                            {
                                // It IS an ID - Check if the char has been seen before or is new
                                if (seenIDs.ContainsKey(id))
                                {
                                    if (inputWords[word][c] != seenIDs[id])
                                    {
                                        match = false;
                                    }
                                }
                                else
                                {
                                    seenIDs.Add(id, inputWords[word][c]);
                                }
                            }

                            p += id.Length;
                        }

                        // Input is shorter than pattern!
                        if (p != patternWords[word].Length)
                        {
                            match = false;
                        }
                    }
                }
            }

            return(match);
        }