BoolLiteral.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 / BoolLiteral.cs / 1305376 / BoolLiteral.cs

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

using System.Data.Common.Utils; 
using System.Data.Common.Utils.Boolean;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics; 
using System.Linq;
 
namespace System.Data.Mapping.ViewGeneration.Structures 
{
 
    using DomainBoolExpr = BoolExpr>;
    using DomainNotExpr = NotExpr>;
    using DomainTermExpr = TermExpr>;
 
    // A class that "ties" up all the literals in boolean expressions --
    // e.g., OneOfConst and CellIdBoolean derive from it 
    // Conditions represented by BoolLiterals need to be synchronized with DomainConstraints, 
    // which may be modified upon calling ExpensiveSimplify. This is what
    // the method FixRange is used for. 
    internal abstract class BoolLiteral : InternalBase
    {

        #region Fields 
        internal static readonly IEqualityComparer EqualityComparer = new BoolLiteralComparer();
        internal static readonly IEqualityComparer EqualityIdentifierComparer = new IdentifierComparer(); 
        #endregion 

        #region methods 
        // effects: Creates a term expression of the form: "literal in range with all possible values being domain"

        internal static DomainTermExpr MakeTermExpression(BoolLiteral literal, IEnumerable domain,
                                                      IEnumerable range) 
        {
            Set domainSet = new Set(domain, Constant.EqualityComparer); 
            Set rangeSet = new Set(range, Constant.EqualityComparer); 
            return MakeTermExpression(literal, domainSet, rangeSet);
        } 

        internal static DomainTermExpr MakeTermExpression(BoolLiteral literal, Set domainSet,
                                                          Set rangeSet)
        { 
            domainSet.MakeReadOnly();
            rangeSet.MakeReadOnly(); 
 
            DomainVariable variable =
                new DomainVariable(literal, domainSet, EqualityIdentifierComparer); 

            DomainConstraint constraint =
                    new DomainConstraint(variable, rangeSet);
            DomainTermExpr result = new DomainTermExpr(EqualityComparer>.Default, 
                                                       constraint);
            return result; 
        } 

        // effects: Fixes the range of this using the new values provided in 
        // range and returns a boolean expression corresponding to the new value
        internal abstract DomainBoolExpr FixRange(Set range, MemberDomainMap memberDomainMap);

        internal abstract DomainBoolExpr GetDomainBoolExpression(MemberDomainMap domainMap); 

        // effects: See BoolExpression.RemapBool 
        internal abstract BoolLiteral RemapBool(Dictionary remap); 

        // effects: See BoolExpression.GetRequiredSlots 
        internal abstract void GetRequiredSlots(MemberProjectionIndex projectedSlotMap, bool[] requiredSlots);

        // effects: See BoolExpression.AsCql
        internal abstract StringBuilder AsCql(StringBuilder builder, string blockAlias, bool canSkipIsNotNull); 

        internal abstract StringBuilder AsUserString(StringBuilder builder, string blockAlias, bool canSkipIsNotNull); 
 
        internal abstract StringBuilder AsNegatedUserString(StringBuilder builder, string blockAlias, bool canSkipIsNotNull);
 
        // effects: Checks if the identifier in this is the same as the one in right
        protected virtual bool IsIdentifierEqualTo(BoolLiteral right)
        {
            return IsEqualTo(right); 
        }
 
        // effects: Get the hash code based on the identifier 
        protected virtual int GetIdentifierHash()
        { 
            return GetHash();
        }

        protected abstract bool IsEqualTo(BoolLiteral right); 

        protected abstract int GetHash(); 
 
        #endregion
 
        #region Comparer class
        // This class compares boolean expressions
        private class BoolLiteralComparer : IEqualityComparer
        { 

            public bool Equals(BoolLiteral left, BoolLiteral right) 
            { 
                // Quick check with references
                if (object.ReferenceEquals(left, right)) 
                {
                    // Gets the Null and Undefined case as well
                    return true;
                } 
                // One of them is non-null at least
                if (left == null || right == null) 
                { 
                    return false;
                } 
                // Both are non-null at this point
                return left.IsEqualTo(right);
            }
 
            public int GetHashCode(BoolLiteral literal)
            { 
                return literal.GetHash(); 
            }
        } 
        #endregion

        #region Identifier Comparer class
        // This class compares just the identifier in boolean expressions 
        private class IdentifierComparer : IEqualityComparer
        { 
 
            public bool Equals(BoolLiteral left, BoolLiteral right)
            { 
                // Quick check with references
                if (object.ReferenceEquals(left, right))
                {
                    // Gets the Null and Undefined case as well 
                    return true;
                } 
                // One of them is non-null at least 
                if (left == null || right == null)
                { 
                    return false;
                }
                // Both are non-null at this point
                return left.IsIdentifierEqualTo(right); 
            }
 
            public int GetHashCode(BoolLiteral literal) 
            {
                return literal.GetIdentifierHash(); 
            }
        }
        #endregion
    } 

    internal abstract class TrueFalseLiteral : BoolLiteral 
    { 
        internal override DomainBoolExpr GetDomainBoolExpression(MemberDomainMap domainMap)
        { 
            // Essentially say that the variable can take values true or false and here its value is only true
            IEnumerable actualValues = new Constant[] { new ScalarConstant(true) };
            IEnumerable possibleValues = new Constant[] { new ScalarConstant(true), new ScalarConstant(false) };
            Set variableDomain = new Set(possibleValues, Constant.EqualityComparer).MakeReadOnly(); 
            Set thisDomain = new Set(actualValues, Constant.EqualityComparer).MakeReadOnly();
 
            DomainTermExpr result = MakeTermExpression(this, variableDomain, thisDomain); 
            return result;
        } 

        // effects: Fixes the range of this using the new values provided in
        // range and returns a boolean expression corresponding to the new value
        internal override DomainBoolExpr FixRange(Set range, MemberDomainMap memberDomainMap) 
        {
            Debug.Assert(range.Count == 1, "For BoolLiterals, there should be precisely one value - true or false"); 
            ScalarConstant scalar = (ScalarConstant)range.First(); 
            DomainBoolExpr expr = GetDomainBoolExpression(memberDomainMap);
 
            if ((bool)scalar.Value == false)
            {
                // The range of the variable was "inverted". Return a NOT of
                // the expression 
                expr = new DomainNotExpr(expr);
            } 
            return expr; 
        }
    } 
}

// 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