Пример #1
0
        internal override ConstraintSatisfaction SatisfiesContraint(Model <T> model, ValueCombination combination)
        {
            if (CachedInteraction == null)
            {
                GetExcludedCombinations(model);
            }

            if (CachedInteraction.Parameters.Any((index) => combination.ParameterToValueMap.ContainsKey(index)))
            {
                // supplied combination is a superset
                if (CachedInteraction.Parameters.All((index) => combination.ParameterToValueMap.ContainsKey(index)))
                {
                    var combo = CachedInteraction.Combinations.First((c) => ParameterInteractionTable <T> .MatchCombination(c, combination));
                    return(combo.State == ValueCombinationState.Excluded ? ConstraintSatisfaction.Unsatisfied : ConstraintSatisfaction.Satisfied);
                }
                else
                {
                    return(new ConstraintSatisfactionExpressionVisitor(mapExpressionsToRequiredParams).SatisfiesConstraint(Condition, model, combination));
                }
            }
            else
            {
                // supplied combination is disjoint
                return(ConstraintSatisfaction.InsufficientData);
            }
        }
Пример #2
0
        internal override ConstraintSatisfaction SatisfiesContraint(Model model, ValueCombination combination)
        {
            if (CachedInteraction == null)
            {
                GetExcludedCombinations(model);
            }

            return(InternalConstraintHelpers.SatisfiesContraint(model, combination, CachedInteraction));
        }
Пример #3
0
        internal override ConstraintSatisfaction SatisfiesContraint(Model model, ValueCombination combination)
        {
            ConstraintSatisfaction ifSatisfaction = If.SatisfiesContraint(model, combination);

            if (ifSatisfaction == ConstraintSatisfaction.InsufficientData)
            {
                return(ConstraintSatisfaction.InsufficientData);
            }

            if (ifSatisfaction == ConstraintSatisfaction.Unsatisfied)
            {
                return(ConstraintSatisfaction.Satisfied);
            }

            return(Then.SatisfiesContraint(model, combination));
        }
Пример #4
0
        internal override ConstraintSatisfaction SatisfiesContraint(Model model, ValueCombination combination)
        {
            ConstraintSatisfaction first  = First.SatisfiesContraint(model, combination);
            ConstraintSatisfaction second = Second.SatisfiesContraint(model, combination);

            if (first == ConstraintSatisfaction.Satisfied || second == ConstraintSatisfaction.Satisfied)
            {
                return(ConstraintSatisfaction.Satisfied);
            }

            if (first == ConstraintSatisfaction.Unsatisfied && second == ConstraintSatisfaction.Unsatisfied)
            {
                return(ConstraintSatisfaction.Unsatisfied);
            }

            return(ConstraintSatisfaction.InsufficientData);
        }
Пример #5
0
        internal override ConstraintSatisfaction SatisfiesContraint(Model model, ValueCombination combination)
        {
            var satisfaction = Condition.SatisfiesContraint(model, combination);

            if (satisfaction == ConstraintSatisfaction.InsufficientData)
            {
                return(ConstraintSatisfaction.InsufficientData);
            }

            if (satisfaction == ConstraintSatisfaction.Satisfied)
            {
                return(ConstraintSatisfaction.Unsatisfied);
            }
            else
            {
                return(ConstraintSatisfaction.Satisfied);
            }
        }
        internal override ParameterInteraction GetExcludedCombinations(Model <T> model)
        {
            if (CachedInteraction == null)
            {
                var taggedValues = GetParametersWithTaggedValues(model);
                CachedInteraction = new ParameterInteraction(taggedValues.Select((p) => p.ParameterIndex));
                var combinationIndices = ParameterInteractionTable <T> .GenerateValueTable(model.Parameters, CachedInteraction);

                foreach (var combinationIndex in combinationIndices)
                {
                    int tagCount = 0;
                    ValueCombination combination = new ValueCombination(combinationIndex, CachedInteraction);
                    combination.State = ValueCombinationState.Covered;

                    for (int i = 0; i < taggedValues.Count; i++)
                    {
                        if (taggedValues[i].ValueIndices.BinarySearch(combinationIndex[i]) >= 0)
                        {
                            tagCount++;
                        }

                        if (tagCount > 1)
                        {
                            break;
                        }
                    }

                    if (tagCount > 1)
                    {
                        combination.State = ValueCombinationState.Excluded;
                    }

                    CachedInteraction.Combinations.Add(combination);
                }
            }

            return(new ParameterInteraction(CachedInteraction));
        }
Пример #7
0
 internal override ConstraintSatisfaction SatisfiesContraint(Model <T> model, ValueCombination combination)
 {
     return(InnerConstraint.SatisfiesContraint(model, combination));
 }
        public ConstraintSatisfaction SatisfiesConstraint <T>(Expression expression, Model <T> model, ValueCombination combination) where T : new()
        {
            switch (expression.NodeType)
            {
            case ExpressionType.AndAlso:
            {
                var andAlso = (BinaryExpression)expression;
                ConstraintSatisfaction left = SatisfiesConstraint(andAlso.Left, model, combination);
                if (left == ConstraintSatisfaction.Unsatisfied)
                {
                    return(ConstraintSatisfaction.Unsatisfied);
                }

                ConstraintSatisfaction right = SatisfiesConstraint(andAlso.Right, model, combination);
                if (right == ConstraintSatisfaction.Unsatisfied)
                {
                    return(ConstraintSatisfaction.Unsatisfied);
                }

                if (left == right)
                {
                    return(left);
                }
                else
                {
                    return(ConstraintSatisfaction.InsufficientData);
                }
            }

            case ExpressionType.Conditional:
                var conditional             = (ConditionalExpression)expression;
                ConstraintSatisfaction test = SatisfiesConstraint(conditional.Test, model, combination);
                if (test == ConstraintSatisfaction.InsufficientData)
                {
                    return(ConstraintSatisfaction.InsufficientData);
                }

                if (test == ConstraintSatisfaction.Satisfied)
                {
                    return(SatisfiesConstraint(conditional.IfTrue, model, combination));
                }
                else
                {
                    return(SatisfiesConstraint(conditional.IfFalse, model, combination));
                }

            case ExpressionType.Lambda:
                return(SatisfiesConstraint(((LambdaExpression)expression).Body, model, combination));

            case ExpressionType.OrElse:
            {
                var orElse = (BinaryExpression)expression;
                ConstraintSatisfaction left = SatisfiesConstraint(orElse.Left, model, combination);
                if (left == ConstraintSatisfaction.Satisfied)
                {
                    return(ConstraintSatisfaction.Satisfied);
                }

                ConstraintSatisfaction right = SatisfiesConstraint(orElse.Right, model, combination);
                if (right == ConstraintSatisfaction.Satisfied)
                {
                    return(ConstraintSatisfaction.Satisfied);
                }

                if (left == right)
                {
                    return(left);
                }
                else
                {
                    return(ConstraintSatisfaction.InsufficientData);
                }
            }

            default:
                if (!mapExpressionsToRequiredParams.ContainsKey(expression))
                {
                    throw new InternalVariationGenerationException("Expected data for expression not found.");
                }
                return(InternalConstraintHelpers.SatisfiesContraint(model, combination, mapExpressionsToRequiredParams[expression].Interaction));
            }
        }
Пример #9
0
 /// <summary>
 /// Calcultes whether the specified value satisfies the constraint or has insufficient data to do so.
 /// </summary>
 /// <param name="model">The model.</param>
 /// <param name="combination">The value.</param>
 /// <returns>The calculated result.</returns>
 internal abstract ConstraintSatisfaction SatisfiesContraint(Model model, ValueCombination combination);