Beispiel #1
0
        public void PrepareDirty(RuleInstance ruleInstance)
        {
            var contextOfConvertingExpressionNode = new ContextOfConvertingExpressionNode();

            Expression.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, this);

            HasQuestionVars = contextOfConvertingExpressionNode.HasQuestionVars;
            HasVars         = contextOfConvertingExpressionNode.HasVars;

#if DEBUG
            //_gbcLogger.Info($"HasVars = {HasVars}");
#endif

            RelationsDict = contextOfConvertingExpressionNode.RelationsList.GroupBy(p => p.Name).ToDictionary(p => p.Key, p => (IList <LogicalQueryNode>)p.ToList());
        }
Beispiel #2
0
        private void FillRelationParams(IList <LogicalQueryNode> sourceParamsList, ContextOfConvertingExpressionNode contextOfConvertingExpressionNode)
        {
            CountParams = sourceParamsList.Count;

            var varsInfoList  = new List <QueryExecutingCardAboutVar>();
            var knownInfoList = new List <QueryExecutingCardAboutKnownInfo>();
            var i             = 0;

            foreach (var param in sourceParamsList)
            {
                param.CheckDirty();

#if DEBUG
                //_gbcLogger.Info($"param = {param}");
#endif

                var kindOfParam = param.Kind;
                switch (kindOfParam)
                {
                case KindOfLogicalQueryNode.Concept:
                case KindOfLogicalQueryNode.Entity:
                case KindOfLogicalQueryNode.Value:
                case KindOfLogicalQueryNode.FuzzyLogicNonNumericSequence:
                case KindOfLogicalQueryNode.Relation:
                {
                    var knownInfo = new QueryExecutingCardAboutKnownInfo();
                    knownInfo.Kind       = kindOfParam;
                    knownInfo.Expression = param;
                    knownInfo.Position   = i;
                    knownInfoList.Add(knownInfo);

#if DEBUG
                    //_gbcLogger.Info($"knownInfo = {knownInfo}");
#endif
                }
                break;

                case KindOfLogicalQueryNode.LogicalVar:
                {
                    var varInfo = new QueryExecutingCardAboutVar();
                    varInfo.NameOfVar = param.Name;
                    varInfo.Position  = i;
                    varsInfoList.Add(varInfo);

                    contextOfConvertingExpressionNode.HasVars = true;
                }
                break;

                case KindOfLogicalQueryNode.QuestionVar:
                {
                    var varInfo = new QueryExecutingCardAboutVar();
                    varInfo.NameOfVar = param.Name;
                    varInfo.Position  = i;
                    varsInfoList.Add(varInfo);

                    contextOfConvertingExpressionNode.HasQuestionVars = true;
                }
                break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(kindOfParam), kindOfParam, null);
                }
                i++;
            }

            VarsInfoList  = varsInfoList;
            KnownInfoList = knownInfoList;

            contextOfConvertingExpressionNode.RelationsList.Add(this);
        }
Beispiel #3
0
        //public bool HasQuestionVars
        //{
        //    get
        //    {
        //        if(IsQuestion)
        //        {
        //            return true;
        //        }

        //        if(Left != null && Left.HasQuestionVars)
        //        {
        //            return true;
        //        }

        //        if(Right != null && Right.HasQuestionVars)
        //        {
        //            return true;
        //        }

        //        if (ParamsList != null && ParamsList.Any(p => p.HasQuestionVars))
        //        {
        //            return true;
        //        }

        //        return false;
        //    }
        //}

        public void PrepareDirty(ContextOfConvertingExpressionNode contextOfConvertingExpressionNode, RuleInstance ruleInstance, BaseRulePart rulePart)
        {
#if DEBUG
            //_gbcLogger.Info($"this = {this}");
            //_gbcLogger.Info($"contextOfConvertingExpressionNode = {contextOfConvertingExpressionNode}");
#endif

            RuleInstance = ruleInstance;
            RulePart     = rulePart;

            switch (Kind)
            {
            case KindOfLogicalQueryNode.BinaryOperator:
                switch (KindOfOperator)
                {
                case KindOfOperatorOfLogicalQueryNode.And:
                case KindOfOperatorOfLogicalQueryNode.Or:
                case KindOfOperatorOfLogicalQueryNode.Is:
                case KindOfOperatorOfLogicalQueryNode.IsNot:
                case KindOfOperatorOfLogicalQueryNode.More:
                case KindOfOperatorOfLogicalQueryNode.MoreOrEqual:
                case KindOfOperatorOfLogicalQueryNode.Less:
                case KindOfOperatorOfLogicalQueryNode.LessOrEqual:
                    Left.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
                    Right.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(KindOfOperator), KindOfOperator, null);
                }
                break;

            case KindOfLogicalQueryNode.UnaryOperator:
                switch (KindOfOperator)
                {
                case KindOfOperatorOfLogicalQueryNode.Not:
                    Left.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(KindOfOperator), KindOfOperator, null);
                }
                break;

            case KindOfLogicalQueryNode.Concept:
            case KindOfLogicalQueryNode.Entity:
            case KindOfLogicalQueryNode.QuestionVar:
                Name.CheckDirty();
                break;

            case KindOfLogicalQueryNode.LogicalVar:
                contextOfConvertingExpressionNode.HasVars = true;
                Name.CheckDirty();
                break;

            case KindOfLogicalQueryNode.Value:
            case KindOfLogicalQueryNode.StubParam:
            case KindOfLogicalQueryNode.EntityCondition:
            case KindOfLogicalQueryNode.EntityRef:
                break;

            case KindOfLogicalQueryNode.FuzzyLogicNonNumericSequence:
                FuzzyLogicNonNumericSequenceValue.CheckDirty();
                break;

            case KindOfLogicalQueryNode.Relation:
                Name.CheckDirty();
                if (Name.KindOfName == KindOfName.LogicalVar)
                {
                    IsQuestion = true;
                }
                FillRelationParams(ParamsList, contextOfConvertingExpressionNode);
                break;

            case KindOfLogicalQueryNode.Group:
                Left.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(Kind), Kind, null);
            }

#if DEBUG
            //_gbcLogger.Info($"contextOfConvertingExpressionNode (after) = {contextOfConvertingExpressionNode}");
#endif
        }