Domain.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Map / ViewGeneration / Structures / Domain.cs / 1305376 / Domain.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System.Data.Common.Utils; 
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Data.Metadata.Edm; 
using System.Data.Mapping.ViewGeneration.Utils;
using System.Linq; 
using System.Data.Entity; 

namespace System.Data.Mapping.ViewGeneration.Structures 
{

    using CellConstantSet = Set;
 
    // A set of cell constants -- to keep track of a cell constant's domain
    // values. It encapsulates the notions of NULL, NOT NULL and can be 
    // enhanced in the future with more functionality 
    // To represent "infinite" domains such as integer, a special constant CellConstant.NotNull is used.
    // For example: domain of System.Boolean is {true, false}, domain of 
    // (nullable) System.Int32 property is {Null, NotNull}.
    internal class Domain : InternalBase
    {
 
        #region Constructors
        // effects: Creates an "fully-done" set with no values -- possibleDiscreteValues are the values 
        // that this domain can take 
        internal Domain(Constant value, IEnumerable possibleDiscreteValues) :
            this(new Constant[] { value }, possibleDiscreteValues) 
        {
        }

        // effects: Creates a domain populated using values -- possibleValues 
        // are all possible values that this can take
        internal Domain(IEnumerable values, 
                                    IEnumerable possibleDiscreteValues) 
        {
            // Note that the values can contain both null and not null 
            Debug.Assert(values != null);
            Debug.Assert(possibleDiscreteValues != null);
            // Determine the possibleValues first and then create the negatedConstant
            m_possibleValues = DeterminePossibleValues(values, possibleDiscreteValues); 

            // Now we need to make sure that m_domain is correct. if "values" (v) already has 
            // the negated stuff, we need to make sure it is in conformance 
            // with what m_possibleValues (p) has
 
            // For NOT --> Add all constants into d that are present in p but
            // not in the NOT
            // v = 1, NOT(1, 2); p = 1, 2, 3 => d = 1, NOT(1, 2, 3), 3
            // v = 1, 2, NOT(1); p = 1, 2, 4 => d = 1, 2, 4, NOT(1, 2, 4) 
            // v = 1, 2, NOT(1, 2, 4), NOT(1, 2, 4, 5); p = 1, 2, 4, 5, 6 =>
            // d = 1, 2, 5, 6, NOT(1, 2, 4, 5, 6) 
 
            // NotNull works naturally now. If possibleValues has (1, 2,
            // NULL) and values has NOT(NULL), add 1, 2 to m_domain 

            m_domain = ExpandNegationsInDomain(values, m_possibleValues);
            AssertInvariant();
        } 

        // effects: Creates a copy of the set "domain" 
        internal Domain(Domain domain) 
        {
            m_domain = new Set(domain.m_domain, Constant.EqualityComparer); 
            m_possibleValues = new Set(domain.m_possibleValues, Constant.EqualityComparer);
            AssertInvariant();
        }
        #endregion 

        #region Fields 
        // The set of values in the cell constant domain 
        private CellConstantSet m_domain; // e.g., 1, 2, NULL, NOT(1, 2, NULL)
        private CellConstantSet m_possibleValues; // e.g., 1, 2, NULL, Undefined 
        // Invariant: m_domain is a subset of m_possibleValues except for a
        // negated constant
        #endregion
 
        #region Properties
        // effects: Returns all the possible values that this can contain (including the negated constants) 
        internal IEnumerable AllPossibleValues 
        {
            get { return AllPossibleValuesInternal; } 
        }

        // effects: Returns all the possible values that this can contain (including the negated constants)
        private Set AllPossibleValuesInternal 
        {
            get 
            { 
                NegatedConstant negatedPossibleValue = new NegatedConstant(m_possibleValues);
                return m_possibleValues.Union(new Constant[] { negatedPossibleValue }); 
            }
        }

        // effects: Returns the number of constants in this (including a negated constant) 
        internal int Count
        { 
            get { return m_domain.Count; } 
        }
 
        // effects: Yields all the values in this
        internal IEnumerable Values
        {
            get { return m_domain; } 
        }
        #endregion 
 
        #region Static Helper Methods to create cell constant sets from metadata
        // effects: Given a member, determines all possible values that can be created from Metadata 
        internal static CellConstantSet DeriveDomainFromMemberPath(MemberPath memberPath, EdmItemCollection edmItemCollection, bool leaveDomainUnbounded)
        {
            CellConstantSet domain = DeriveDomainFromType(memberPath.EdmType, edmItemCollection, leaveDomainUnbounded);
            if (memberPath.IsNullable) 
            {
                domain.Add(Constant.Null); 
            } 
            return domain;
        } 


        // effects: Given a type, determines all possible values that can be created from Metadata
        private static CellConstantSet DeriveDomainFromType(EdmType type, EdmItemCollection edmItemCollection, bool leaveDomainUnbounded) 
        {
            CellConstantSet domain = null; 
            PrimitiveType scalarType = type as PrimitiveType; 
            EnumType enumType = type as EnumType;
 
            if (scalarType != null) //if Scalar Type
            {
                // Get the domain for scalars -- for booleans, we special case.
                if (scalarType.PrimitiveTypeKind == PrimitiveTypeKind.Boolean) 
                {
                    // Closed domain 
                    domain = new Set(CreateList(true, false), Constant.EqualityComparer); 
                }
                else 
                {
                    // Unbounded domain
                    domain = new Set(Constant.EqualityComparer);
                    if (leaveDomainUnbounded) 
                    {
                        domain.Add(Constant.NotNull); 
                    } 
                }
            } 
            else if (enumType != null) //If Enumeration Type
            {
                // Get all the values for the enumeration
                domain = GetEnumeratedDomain(enumType); 
            }
            else //Type Constants - Domain is all possible concrete subtypes 
            { 
                Debug.Assert(Helper.IsEntityType(type) || Helper.IsComplexType(type) || Helper.IsRefType(type) || Helper.IsAssociationType(type));
 
                // Treat ref types as their referenced entity types
                if (Helper.IsRefType(type))
                {
                    type = ((RefType)type).ElementType; 
                }
 
                List types = new List(); 
                foreach (EdmType derivedType in MetadataHelper.GetTypeAndSubtypesOf(type, edmItemCollection, false /*includeAbstractTypes*/))
                { 
                    TypeConstant derivedTypeConstant = new TypeConstant(derivedType);
                    types.Add(derivedTypeConstant);
                }
                domain = new Set(types, Constant.EqualityComparer); 
            }
 
            Debug.Assert(domain != null, "Domain not set up for some type"); 
            return domain;
        } 

        // effect: returns the default value for the member
        // if the member is nullable and has no default, changes default value to CellConstant.NULL and returns true
        // if the mebmer is not nullable and has no default, returns false 
        // CHANGE_[....]_FEATURE_DEFAULT_VALUES: return the right default once metadata supports it
        internal static bool TryGetDefaultValueForMemberPath(MemberPath memberPath, out Constant defaultConstant) 
        { 
            object defaultValue = memberPath.DefaultValue;
            defaultConstant = Constant.Null; 
            if (defaultValue != null)
            {
                defaultConstant = new ScalarConstant(defaultValue);
                return true; 
            }
            else if (memberPath.IsNullable || memberPath.IsComputed) 
            { 
                return true;
            } 
            return false;
        }

        internal static Constant GetDefaultValueForMemberPath(MemberPath memberPath, IEnumerable wrappersForErrorReporting, 
                                                                  ConfigViewGenerator config)
        { 
            Constant defaultValue = null; 
            if (!Domain.TryGetDefaultValueForMemberPath(memberPath, out defaultValue))
            { 
                string message = Strings.ViewGen_No_Default_Value_1(memberPath.Extent.Name, memberPath.PathToString(false));
                ErrorLog.Record record = new ErrorLog.Record(true, ViewGenErrorCode.NoDefaultValue, message, wrappersForErrorReporting, String.Empty);
                ExceptionHelpers.ThrowMappingException(record, config);
            } 
            return defaultValue;
        } 
 
        // effects: Given an enumeration type, enumType, returns the set of
        // values that enumType can take 
        private static CellConstantSet GetEnumeratedDomain(EnumType enumType)
        {
            Set values = new Set(Constant.EqualityComparer);
            foreach (EnumMember enumerationValue in enumType.EnumMembers) 
            {
                values.Add(new ScalarConstant(enumerationValue)); 
            } 
            return values;
        } 
        #endregion

        #region External methods
        internal int GetHash() 
        {
            int result = 0; 
            foreach (Constant constant in m_domain) 
            {
                result ^= Constant.EqualityComparer.GetHashCode(constant); 
            }
            return result;
        }
 
        // effects: Returns true iff this domain has the same values as
        // second. Note that this method performs a semantic check not just 
        // an element by element check 
        internal bool IsEqualTo(Domain second)
        { 
            return m_domain.SetEquals(second.m_domain);
        }

        // requires: this is fully done 
        // effects: Returns true iff this contains NOT(NULL OR ....)
        internal bool ContainsNotNull() 
        { 
            NegatedConstant negated = GetNegatedConstant(m_domain);
            return negated != null && negated.Contains(Constant.Null); 
        }

        /// 
        /// Returns true if the domain contains the given Cell Constant 
        /// 
        internal bool Contains(Constant constant) 
        { 
            return m_domain.Contains(constant);
        } 

        // effects: Given a set of values in domain, "normalizes" it, i.e.,
        // all positive constants are seperated out and any negative constant
        // is changed s.t. it is the negative of all positive values 
        // extraValues indicates more constants that domain could take, e.g.,
        // domain could be "1, 2, NOT(1, 2)", extraValues could be "3". In 
        // this case, we return "1, 2, 3, NOT(1, 2, 3)" 
        internal static CellConstantSet ExpandNegationsInDomain(IEnumerable domain, IEnumerable otherPossibleValues)
        { 

            //Finds all constants referenced in (domain UNION extraValues) e.g: 1, NOT(2) =>  1, 2
            CellConstantSet possibleValues = DeterminePossibleValues(domain, otherPossibleValues);
 
            // For NOT --> Add all constants into d that are present in p but
            // not in the NOT 
            // v = 1, NOT(1, 2); p = 1, 2, 3 => d = 1, NOT(1, 2, 3), 3 
            // v = 1, 2, NOT(1); p = 1, 2, 4 => d = 1, 2, 4, NOT(1, 2, 4)
            // v = 1, 2, NOT(1, 2, 4), NOT(1, 2, 4, 5); p = 1, 2, 4, 5, 6 => d = 1, 2, 5, 6, NOT(1, 2, 4, 5, 6) 

            // NotNull works naturally now. If possibleValues has (1, 2, NULL)
            // and values has NOT(NULL), add 1, 2 to m_domain
            CellConstantSet result = new Set(Constant.EqualityComparer); 

            foreach (Constant constant in domain) 
            { 
                NegatedConstant negated = constant as NegatedConstant;
                if (negated != null) 
                {
                    result.Add(new NegatedConstant(possibleValues));
                    // Compute all elements in possibleValues that are not present in negated. E.g., if
                    // negated is NOT(1, 2, 3) and possibleValues is 1, 2, 3, 
                    // 4, we need to add 4 to result
                    CellConstantSet remainingElements = possibleValues.Difference(negated.Elements); 
                    result.AddRange(remainingElements); 
                }
                else 
                {
                    result.Add(constant);
                }
            } 
            return result;
 
        } 

        internal static CellConstantSet ExpandNegationsInDomain(IEnumerable domain) 
        {
            return ExpandNegationsInDomain(domain, domain);
        }
 

        // effects: Given a set of values in domain 
        // Returns all possible values that are present in domain. 
        static CellConstantSet DeterminePossibleValues(IEnumerable domain)
        { 

            // E.g., if we have 1, 2, NOT(1) --> Result = 1, 2
            // 1, NOT(1, 2) --> Result = 1, 2
            // 1, 2, NOT(NULL) --> Result = 1, 2, NULL 
            // 1, 2, NOT(2), NOT(3, 4) --> Result = 1, 2, 3, 4
 
            CellConstantSet result = new CellConstantSet(Constant.EqualityComparer); 

            foreach (Constant constant in domain) 
            {
                NegatedConstant negated = constant as NegatedConstant;

                if (negated != null) 
                {
 
                    // Go through all the constants in negated and add them to domain 
                    // We add them to possible values also even if (say) Null is not allowed because we want the complete
                    // partitioning of the space, e.g., if the values specified by the caller are 1, NotNull -> we want 1, Null 
                    foreach (Constant constElement in negated.Elements)
                    {
                        Debug.Assert(constElement as NegatedConstant == null, "Negated cell constant inside NegatedCellConstant");
                        result.Add(constElement); 
                    }
                } 
                else 
                {
                    result.Add(constant); 
                }
            }

            return result; 
        }
        #endregion 
 
        #region Helper methods for determining domains from cells
        // effects: Given a set of cells, returns all the different values 
        // that each memberPath in cells can take
        internal static Dictionary
            ComputeConstantDomainSetsForSlotsInQueryViews(IEnumerable cells, EdmItemCollection edmItemCollection, bool isValidationEnabled)
        { 

            Dictionary cDomainMap = 
                new Dictionary(MemberPath.EqualityComparer); 

            foreach (Cell cell in cells) 
            {
                CellQuery cQuery = cell.CQuery;
                // Go through the conjuncts to get the constants (e.g., we
                // just don't want to NULL, NOT(NULL). We want to say that 
                // the possible values are NULL, 4, NOT(NULL, 4)
                foreach (MemberRestriction restriction in cQuery.GetConjunctsFromWhereClause()) 
                { 
                    MemberProjectedSlot slot = restriction.RestrictedMemberSlot;
                    CellConstantSet cDomain = DeriveDomainFromMemberPath(slot.MemberPath, edmItemCollection, isValidationEnabled); 
                    // Now we add the domain of oneConst into this
                    //Isnull=true and Isnull=false conditions should not contribute to a member's domain
                    cDomain.AddRange(restriction.Domain.Values.Where(c => !(c.Equals(Constant.Null) || c.Equals(Constant.NotNull))));
                    CellConstantSet values; 
                    bool found = cDomainMap.TryGetValue(slot.MemberPath, out values);
                    if (!found) 
                    { 
                        cDomainMap[slot.MemberPath] = cDomain;
                    } 
                    else
                    {
                        values.AddRange(cDomain);
                    } 
                }
            } 
            return cDomainMap; 
        }
 
        //True = domain is restricted, False = domain is not restricted (because there is no condition)
        private static bool GetRestrictedOrUnrestrictedDomain(MemberProjectedSlot slot, CellQuery cellQuery, EdmItemCollection edmItemCollection, out CellConstantSet domain)
        {
            CellConstantSet domainValues = DeriveDomainFromMemberPath(slot.MemberPath, edmItemCollection, true /* leaveDomainUnbounded */); 

            //Note, out domain is set even in the case where method call returns false 
            return TryGetDomainRestrictedByWhereClause(domainValues, slot, cellQuery, out domain); 
        }
 

        // effects: returns a dictionary that maps each S-side slot whose domain can be restricted to such an enumerated domain
        // The resulting domain is a union of
        // (a) constants appearing in conditions on that slot on S-side 
        // (b) constants appearing in conditions on the respective slot on C-side, if the given slot
        //     is projected (on the C-side) and no conditions are placed on it on S-side 
        // (c) default value of the slot based on metadata 
        internal static Dictionary
            ComputeConstantDomainSetsForSlotsInUpdateViews(IEnumerable cells, EdmItemCollection edmItemCollection) 
        {

            Dictionary updateDomainMap = new Dictionary(MemberPath.EqualityComparer);
 
            foreach (Cell cell in cells)
            { 
 
                CellQuery cQuery = cell.CQuery;
                CellQuery sQuery = cell.SQuery; 

                foreach (MemberProjectedSlot sSlot in sQuery.GetConjunctsFromWhereClause().Select(oneOfConst => oneOfConst.RestrictedMemberSlot))
                {
 
                    // obtain initial slot domain and restrict it if the slot has conditions
 
 
                    CellConstantSet restrictedDomain;
                    bool wasDomainRestricted = GetRestrictedOrUnrestrictedDomain(sSlot, sQuery, edmItemCollection, out restrictedDomain); 

                    // Suppose that we have a cell:
                    //      Proj(ID, A) WHERE(A=5) FROM E   =   Proj(ID, B) FROM T
 
                    // In the above cell, B on the S-side is 5 and we add that to its range. But if B had a restriction,
                    // we do not add 5. Note that do we not have a problem w.r.t. possibleValues since if A=5 and B=1, we have an 
                    // empty cell -- we should catch that as an error. If A = 5 and B = 5 is present then restrictedDomain 
                    // and domainValues are the same
 
                    // if no restriction on the S-side and the slot is projected then take the domain from the C-side
                    if (!wasDomainRestricted)
                    {
                        int projectedPosition = sQuery.GetProjectedPosition(sSlot); 
                        if (projectedPosition >= 0)
                        { 
                            // get the domain of the respective C-side slot 
                            MemberProjectedSlot cSlot = cQuery.ProjectedSlotAt(projectedPosition) as MemberProjectedSlot;
                            Debug.Assert(cSlot != null, "Assuming constants are not projected"); 

                            wasDomainRestricted = GetRestrictedOrUnrestrictedDomain(cSlot, cQuery, edmItemCollection, out restrictedDomain);

                            if (!wasDomainRestricted) 
                            {
                                continue; 
                            } 
                        }
                    } 

                    // Add the default value to the domain
                    MemberPath sSlotMemberPath = sSlot.MemberPath;
                    Constant defaultValue; 
                    if (TryGetDefaultValueForMemberPath(sSlotMemberPath, out defaultValue))
                    { 
                        restrictedDomain.Add(defaultValue); 
                    }
 
                    // add all constants appearing in the domain to sDomainMap
                    CellConstantSet sSlotDomain;
                    if (!updateDomainMap.TryGetValue(sSlotMemberPath, out sSlotDomain))
                    { 
                        updateDomainMap[sSlotMemberPath] = restrictedDomain;
                    } 
                    else 
                    {
                        sSlotDomain.AddRange(restrictedDomain); 
                    }
                }
            }
            return updateDomainMap; 
        }
 
        // requires: domain not have any Negated constants other than NotNull 
        // Also, cellQuery contains all final oneOfConsts or all partial oneOfConsts
        // cellquery must contain a whereclause of the form "True", "OneOfConst" or " 
        // "OneOfConst AND ... AND OneOfConst"
        // slot must present in cellQuery and incomingDomain is the domain for it
        // effects: Returns the set of values that slot can take as restricted by cellQuery's whereClause
        private static bool TryGetDomainRestrictedByWhereClause(IEnumerable domain, MemberProjectedSlot slot, CellQuery cellQuery, out CellConstantSet result) 
        {
 
            var conditionsForSlot = cellQuery.GetConjunctsFromWhereClause() 
                                  .Where(restriction => MemberPath.EqualityComparer.Equals(restriction.RestrictedMemberSlot.MemberPath, slot.MemberPath))
                                  .Select(restriction => new CellConstantSet(restriction.Domain.Values, Constant.EqualityComparer)); 

            //Debug.Assert(!conditionsForSlot.Skip(1).Any(), "More than one Clause with the same path");

            if (!conditionsForSlot.Any()) 
            {
                // If the slot was not mentioned in the query return the domain without restricting it 
                result = new CellConstantSet(domain); 
                return false;
            } 



            // Now get all the possible values from domain and conditionValues 
            CellConstantSet possibleValues = DeterminePossibleValues(conditionsForSlot.SelectMany(m => m.Select(c => c)), domain);
 
            Domain restrictedDomain = new Domain(domain, possibleValues); 
            foreach (var conditionValues in conditionsForSlot)
            { 
                // Domain derived from Edm-Type INTERSECTED with Conditions
                restrictedDomain = restrictedDomain.Intersect(new Domain(conditionValues, possibleValues));
            }
 
            result = new CellConstantSet(restrictedDomain.Values, Constant.EqualityComparer);
            return !domain.SequenceEqual(result); 
        } 
        #endregion
 
        #region Private helper methods
        // effects: Intersects the values in second with this domain and
        // returns the result
        private Domain Intersect(Domain second) 
        {
            CheckTwoDomainInvariants(this, second); 
            Domain result = new Domain(this); 
            result.m_domain.Intersect(second.m_domain);
            return result; 
        }

        // requires: constants has at most one NegatedCellConstant
        // effects: Returns the NegatedCellConstant in this if any. Else 
        // returns null
        private static NegatedConstant GetNegatedConstant(IEnumerable constants) 
        { 
            NegatedConstant result = null;
            foreach (Constant constant in constants) 
            {
                NegatedConstant negated = constant as NegatedConstant;
                if (negated != null)
                { 
                    Debug.Assert(result == null, "Multiple negated cell constants?");
                    result = negated; 
                } 
            }
            return result; 
        }

        // effects: Given a set of values in domain1 and domain2,
        // Returns all possible positive values that are present in domain1 and domain2 
        private static CellConstantSet DeterminePossibleValues(IEnumerable domain1, IEnumerable domain2)
        { 
            CellConstantSet union = new CellConstantSet(domain1, Constant.EqualityComparer).Union(domain2); 
            CellConstantSet result = DeterminePossibleValues(union);
            return result; 
        }

        // effects: Checks that two domains, domain1 and domain2, that are being compared/unioned/intersected, etc
        // are compatible with each other 
        [Conditional("DEBUG")]
        private static void CheckTwoDomainInvariants(Domain domain1, Domain domain2) 
        { 
            domain1.AssertInvariant();
            domain2.AssertInvariant(); 

            // The possible values must match
            Debug.Assert(domain1.m_possibleValues.SetEquals(domain2.m_possibleValues), "domains must be compatible");
        } 

        // effects: A helper method. Given two 
        // values, yields a list of CellConstants in the order of values 
        private static IEnumerable CreateList(object value1, object value2)
        { 
            yield return new ScalarConstant(value1);
            yield return new ScalarConstant(value2);
        }
 
        // effects: Checks the invariants in "this"
        internal void AssertInvariant() 
        { 
            // Make sure m_domain has at most one negatedCellConstant
            //  m_possibleValues has none 
            NegatedConstant negated = GetNegatedConstant(m_domain); // Can be null or not-null

            negated = GetNegatedConstant(m_possibleValues);
            Debug.Assert(negated == null, "m_possibleValues cannot contain negated constant"); 

            Debug.Assert(m_domain.IsSubsetOf(AllPossibleValuesInternal), 
                         "All domain values must be contained in possibleValues"); 
        }
        #endregion 

        #region String methods
        // effects: Returns a user-friendly string that can be reported to an end-user
        internal string ToUserString() 
        {
            StringBuilder builder = new StringBuilder(); 
            bool isFirst = true; 
            foreach (Constant constant in m_domain)
            { 
                if (isFirst == false)
                {
                    builder.Append(", ");
                } 
                builder.Append(constant.ToUserString());
                isFirst = false; 
            } 
            return builder.ToString();
        } 

        internal override void ToCompactString(StringBuilder builder)
        {
            builder.Append(ToUserString()); 
        }
        #endregion 
 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK