Example #1
0
        // effects: Given a term expression, extracts the BoolLiteral from it
        internal static BoolLiteral GetBoolLiteral(DomainTermExpr term)
        {
            DomainConstraint <BoolLiteral, Constant> domainConstraint = term.Identifier;
            DomainVariable <BoolLiteral, Constant>   variable         = domainConstraint.Variable;

            return(variable.Identifier);
        }
 private DomainVariable <string, ValueCondition>[] ConstructDomainVariables()
 {
     Set <ValueCondition>[] setArray = new Set <ValueCondition> [this.DiscriminatorColumns.Count];
     for (int index = 0; index < setArray.Length; ++index)
     {
         setArray[index] = new Set <ValueCondition>();
         setArray[index].Add(ValueCondition.IsOther);
         setArray[index].Add(ValueCondition.IsNull);
     }
     foreach (FunctionImportNormalizedEntityTypeMapping entityTypeMapping in this.NormalizedEntityTypeMappings)
     {
         for (int index = 0; index < this.DiscriminatorColumns.Count; ++index)
         {
             FunctionImportEntityTypeMappingCondition columnCondition = entityTypeMapping.ColumnConditions[index];
             if (columnCondition != null && !columnCondition.ConditionValue.IsNotNullCondition)
             {
                 setArray[index].Add(columnCondition.ConditionValue);
             }
         }
     }
     DomainVariable <string, ValueCondition>[] domainVariableArray = new DomainVariable <string, ValueCondition> [setArray.Length];
     for (int index = 0; index < domainVariableArray.Length; ++index)
     {
         domainVariableArray[index] = new DomainVariable <string, ValueCondition>(this.DiscriminatorColumns[index], setArray[index].MakeReadOnly());
     }
     return(domainVariableArray);
 }
Example #3
0
        /// <summary>
        /// Creates a term expression of the form: "<paramref name="literal"/> in <paramref name="range"/> with all possible values being <paramref name="domain"/>".
        /// </summary>
        internal static DomainTermExpr MakeTermExpression(BoolLiteral literal, Set <Constant> domain, Set <Constant> range)
        {
            domain.MakeReadOnly();
            range.MakeReadOnly();

            DomainVariable   variable   = new DomainVariable(literal, domain, EqualityIdentifierComparer);
            DomainConstraint constraint = new DomainConstraint(variable, range);
            DomainTermExpr   result     = new DomainTermExpr(EqualityComparer <DomainConstraint> .Default, constraint);

            return(result);
        }
                internal override BoolExpr <DomainConstraint <BoolLiteral, Constant> > VisitTerm(
                    TermExpr <DomainConstraint <BoolLiteral, Constant> > expression)
                {
                    DomainConstraint <BoolLiteral, Constant> domainConstraint = expression.Identifier.InvertDomainConstraint();

                    if (domainConstraint.Range.Count == 0)
                    {
                        return((BoolExpr <DomainConstraint <BoolLiteral, Constant> >)FalseExpr <DomainConstraint <BoolLiteral, Constant> > .Value);
                    }
                    List <BoolExpr <DomainConstraint <BoolLiteral, Constant> > > boolExprList = new List <BoolExpr <DomainConstraint <BoolLiteral, Constant> > >();
                    DomainVariable <BoolLiteral, Constant> variable = domainConstraint.Variable;

                    foreach (Constant constant in domainConstraint.Range)
                    {
                        boolExprList.Add((BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new DomainConstraint <BoolLiteral, Constant>(variable, new Set <Constant>((IEnumerable <Constant>) new Constant[1]
                        {
                            constant
                        }, Constant.EqualityComparer)));
                    }
                    return((BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new OrExpr <DomainConstraint <BoolLiteral, Constant> >((IEnumerable <BoolExpr <DomainConstraint <BoolLiteral, Constant> > >)boolExprList));
                }
        private DomainVariable <string, ValueCondition>[] ConstructDomainVariables()
        {
            // Determine domain for each discriminator column, including "other" and "null" placeholders.
            var discriminatorDomains = new Set <ValueCondition> [DiscriminatorColumns.Count];

            for (var i = 0; i < discriminatorDomains.Length; i++)
            {
                discriminatorDomains[i] = new Set <ValueCondition>();
                discriminatorDomains[i].Add(ValueCondition.IsOther);
                discriminatorDomains[i].Add(ValueCondition.IsNull);
            }

            // Collect all domain values.
            foreach (var typeMapping in NormalizedEntityTypeMappings)
            {
                for (var i = 0; i < DiscriminatorColumns.Count; i++)
                {
                    var discriminatorValue = typeMapping.ColumnConditions[i];
                    if (null != discriminatorValue
                        &&
                        !discriminatorValue.ConditionValue.IsNotNullCondition) // NotNull is a special range (everything but IsNull)
                    {
                        discriminatorDomains[i].Add(discriminatorValue.ConditionValue);
                    }
                }
            }

            var discriminatorVariables = new DomainVariable <string, ValueCondition> [discriminatorDomains.Length];

            for (var i = 0; i < discriminatorVariables.Length; i++)
            {
                // domain variable is identified by the column name and takes all collected domain values
                discriminatorVariables[i] = new DomainVariable <string, ValueCondition>(
                    DiscriminatorColumns[i], discriminatorDomains[i].MakeReadOnly());
            }

            return(discriminatorVariables);
        }
                internal override BoolExpr <DomainConstraint <BoolLiteral, Constant> > VisitTerm(
                    TermExpr <DomainConstraint <BoolLiteral, Constant> > expression)
                {
                    switch (expression.Identifier.Range.Count)
                    {
                    case 0:
                        return((BoolExpr <DomainConstraint <BoolLiteral, Constant> >)FalseExpr <DomainConstraint <BoolLiteral, Constant> > .Value);

                    case 1:
                        return((BoolExpr <DomainConstraint <BoolLiteral, Constant> >)expression);

                    default:
                        List <BoolExpr <DomainConstraint <BoolLiteral, Constant> > > boolExprList = new List <BoolExpr <DomainConstraint <BoolLiteral, Constant> > >();
                        DomainVariable <BoolLiteral, Constant> variable = expression.Identifier.Variable;
                        foreach (Constant constant in expression.Identifier.Range)
                        {
                            boolExprList.Add((BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new DomainConstraint <BoolLiteral, Constant>(variable, new Set <Constant>((IEnumerable <Constant>) new Constant[1]
                            {
                                constant
                            }, Constant.EqualityComparer)));
                        }
                        return((BoolExpr <DomainConstraint <BoolLiteral, Constant> >) new OrExpr <DomainConstraint <BoolLiteral, Constant> >((IEnumerable <BoolExpr <DomainConstraint <BoolLiteral, Constant> > >)boolExprList));
                    }
                }
        private Vertex[] ConvertMappingConditionsToVertices(
            ConversionContext<DomainConstraint<string, ValueCondition>> converter,
            DomainVariable<string, ValueCondition>[] variables)
        {
            var conditions = new Vertex[NormalizedEntityTypeMappings.Count];
            for (var i = 0; i < conditions.Length; i++)
            {
                var typeMapping = NormalizedEntityTypeMappings[i];

                // create conjunction representing the condition
                var condition = Vertex.One;
                for (var j = 0; j < DiscriminatorColumns.Count; j++)
                {
                    var columnCondition = typeMapping.ColumnConditions[j];
                    if (null != columnCondition)
                    {
                        var conditionValue = columnCondition.ConditionValue;
                        if (conditionValue.IsNotNullCondition)
                        {
                            // the 'not null' condition is not actually part of the domain (since it
                            // covers other elements), so create a Not(value in {null}) condition
                            var isNull = new TermExpr<DomainConstraint<string, ValueCondition>>(
                                new DomainConstraint<string, ValueCondition>(variables[j], ValueCondition.IsNull));
                            var isNullVertex = converter.TranslateTermToVertex(isNull);
                            condition = converter.Solver.And(condition, converter.Solver.Not(isNullVertex));
                        }
                        else
                        {
                            var hasValue = new TermExpr<DomainConstraint<string, ValueCondition>>(
                                new DomainConstraint<string, ValueCondition>(variables[j], conditionValue));
                            condition = converter.Solver.And(condition, converter.TranslateTermToVertex(hasValue));
                        }
                    }
                }
                conditions[i] = condition;
            }
            return conditions;
        }
        private DomainVariable<string, ValueCondition>[] ConstructDomainVariables()
        {
            // Determine domain for each discriminator column, including "other" and "null" placeholders.
            var discriminatorDomains = new Set<ValueCondition>[DiscriminatorColumns.Count];
            for (var i = 0; i < discriminatorDomains.Length; i++)
            {
                discriminatorDomains[i] = new Set<ValueCondition>();
                discriminatorDomains[i].Add(ValueCondition.IsOther);
                discriminatorDomains[i].Add(ValueCondition.IsNull);
            }

            // Collect all domain values.
            foreach (var typeMapping in NormalizedEntityTypeMappings)
            {
                for (var i = 0; i < DiscriminatorColumns.Count; i++)
                {
                    var discriminatorValue = typeMapping.ColumnConditions[i];
                    if (null != discriminatorValue
                        &&
                        !discriminatorValue.ConditionValue.IsNotNullCondition) // NotNull is a special range (everything but IsNull)
                    {
                        discriminatorDomains[i].Add(discriminatorValue.ConditionValue);
                    }
                }
            }

            var discriminatorVariables = new DomainVariable<string, ValueCondition>[discriminatorDomains.Length];
            for (var i = 0; i < discriminatorVariables.Length; i++)
            {
                // domain variable is identified by the column name and takes all collected domain values
                discriminatorVariables[i] = new DomainVariable<string, ValueCondition>(
                    DiscriminatorColumns[i], discriminatorDomains[i].MakeReadOnly());
            }

            return discriminatorVariables;
        }