Ejemplo n.º 1
0
        private List <LSyntagm> RecursiveQuery(LSyntagm jokerSyntagm, List <LSyntagm> currentMatches)
        {
            List <LSyntagm> result         = new List <LSyntagm>();
            LSyntagm        jokerParent    = jokerSyntagm.Parents.FirstOrDefault();// Always one parent in question tree.
            List <LSyntagm> currentParents = new List <LSyntagm>();

            if (jokerParent == null)
            {
                return(currentMatches);
            }

            foreach (var match in currentMatches)
            {
                currentParents.AddRange(match.Parents);
            }

            currentParents = currentParents.Distinct().ToList();

            foreach (var parent in currentParents)
            {
                if (jokerParent.Equals(parent))
                {
                    result.Add(parent);
                }
            }

            return(RecursiveQuery(jokerParent, result));
        }
Ejemplo n.º 2
0
        public List <LSyntagm> Match(LSyntagm querySyntagm)
        {
            LSyntagm jokerSyntagm = this.FindJokerStart(querySyntagm);

            string[] startingPrimWords = jokerSyntagm.ToString().Split(' ').Where(w => w != Constants.SAFE_JOKER_TOKEN).ToArray();

            List <LSyntagm> prims = new List <LSyntagm>();

            foreach (string word in startingPrimWords)
            {
                if (this.Primaries.ContainsKey(word))
                {
                    prims.Add(this.Primaries[word]);
                }
            }

            List <LSyntagm> primParents = new List <LSyntagm>();

            foreach (var prim in prims)
            {
                foreach (var parent in prim.Parents)
                {
                    if (!primParents.Contains(parent) && jokerSyntagm.Equals(parent))
                    {
                        primParents.Add(parent);
                    }
                }
            }

            List <LSyntagm> finalResult = new List <LSyntagm>();

            finalResult.AddRange(this.RecursiveQuery(jokerSyntagm, primParents));

            return(finalResult.Distinct().ToList());
        }
Ejemplo n.º 3
0
        public LSyntagm ResolvePrim(string token)
        {
            if (_generalContext.Primaries.ContainsKey(token))
            {
                return(_generalContext.Primaries[token]);
            }
            else
            {
                LSyntagm newPrim = new LSyntagm(token);
                _generalContext.Primaries.Add(token, newPrim);

                return(newPrim);
            }
        }
Ejemplo n.º 4
0
        private LSyntagm FindJokerStart(LSyntagm querySyntagm)
        {
            if (querySyntagm.ToString() == Constants.SAFE_JOKER_TOKEN)
            {
                return(querySyntagm.Parents.First());
            }

            foreach (var child in querySyntagm.Children)
            {
                LSyntagm result = FindJokerStart(child);

                if (result != null)
                {
                    return(result);
                }
            }

            return(null);
        }
Ejemplo n.º 5
0
        public List <LSyntagm> Query(string query)
        {
            LSyntagm querySyntagm = _bridge.GetQuerySyntagmFromText(query);

            return(_generalContext.Match(querySyntagm));
        }