//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Data.Common.Utils.Boolean;
using System.Text;
using System.Data.Common.Utils;
using System.Diagnostics;
using System.Data.Mapping.ViewGeneration.Utils;
using System.Data.Metadata.Edm;
using System.Linq;
namespace System.Data.Mapping.ViewGeneration.Structures {
using DomainBoolExpr = BoolExpr>;
using DomainTermExpr = TermExpr>;
using System.Data.Entity;
// An abstract class that denotes the boolean expression: "var in values"
// An object of this type can be partially or fully done -- A partially
// done object is one whose domain was not created with all possible
// values. Partially done classes have a limited set of methods that can
// be called
internal abstract class OneOfConst : BoolLiteral {
#region Constructors
// effects: Creates a "partial" oneOfConst with the meaning "slot = value". "Partial" means
// that the CellConstantDomain in this is partial - hence the operations on "this" are limited
protected OneOfConst(JoinTreeSlot slot, CellConstant value) : this(slot, new CellConstant[] { value }) {
}
// effects: Creates a "partial" oneOfConst with the meaning "slot in values"
protected OneOfConst(JoinTreeSlot slot, IEnumerable values) {
m_slot = slot;
m_values = new CellConstantDomain(values, values);
}
// effects: Creates an expression of the form "slot in domain"
protected OneOfConst(JoinTreeSlot slot, CellConstantDomain domain) {
m_slot = slot;
m_values = domain;
m_isFullyDone = true;
Debug.Assert(m_values.Count != 0, "If you want a boolean that evaluates to false, " +
"use the ConstantBool abstraction");
}
// effects: Creates an expression of the form "slot = value"
// possibleValues are all the values that slot can take
protected OneOfConst(JoinTreeSlot slot, CellConstant value, IEnumerable possibleValues) :
this(slot, new CellConstantDomain(value, possibleValues)) {
Debug.Assert(possibleValues != null);
}
// effects: Creates an expression of the form "slot in domain"
private static OneOfConst Factory(JoinTreeSlot slot, CellConstantDomain domain, bool isTypeConstant) {
if (isTypeConstant) {
return new OneOfTypeConst(slot, domain);
} else {
return new OneOfScalarConst(slot, domain);
}
}
// effects: Creates an expression of the form "node in values"
// possibleValues are all the values that slot can take
protected OneOfConst(JoinTreeSlot slot, IEnumerable values,
IEnumerable possibleValues) :
this(slot, new CellConstantDomain(values, possibleValues)) {
}
#endregion
#region Fields
// State to keep track of "m_slot in m_values"
private JoinTreeSlot m_slot;
private CellConstantDomain m_values;
private bool m_isFullyDone;
#endregion
#region Properties
internal bool IsFullyDone {
get { return m_isFullyDone;}
}
// effects: Returns the variable in this
internal JoinTreeSlot Slot {
get { return m_slot; }
}
// effects: Returns the values that it is being checked for
internal CellConstantDomain Values {
get { return m_values; }
}
#endregion
#region BoolLiteral Members
// effects: Returns a boolean expression that is domain-aware and
// ready for optimizations etc. domainMap maps members to the values
// that each member can take -- it can be null in which case the
// possible and actual values are the same
internal override DomainBoolExpr GetDomainBoolExpression(MemberDomainMap domainMap) {
// Get the variable name from the slot's memberpath and the possible domain values from the slot
DomainTermExpr result;
if (domainMap != null) {
// Look up the domain from the domainMap
IEnumerable domain = domainMap.GetDomain(m_slot.MemberPath);
result = MakeTermExpression(this, domain, m_values.Values);
} else {
result = MakeTermExpression(this, m_values.AllPossibleValues, m_values.Values);
}
return result;
}
// oneOfConst can be partial
// effects: Creates a OneOfConst based on existing oneofconst with
// possible values for the domain being given by possibleValues
internal static OneOfConst CreateFullOneOfConst(OneOfConst oneOfConst, IEnumerable possibleValues) {
if (oneOfConst is OneOfTypeConst) {
return new OneOfTypeConst(oneOfConst.Slot, new CellConstantDomain(oneOfConst.Values.Values, possibleValues));
} else {
return new OneOfScalarConst(oneOfConst.Slot, new CellConstantDomain(oneOfConst.Values.Values, possibleValues));
}
}
// effects: See BoolLiteral.GetRequiredSlots
internal override void GetRequiredSlots(MemberPathMapBase projectedSlotMap, bool[] requiredSlots) {
// Simply get the slot for the variable var in "var in values"
MemberPath member = Slot.MemberPath;
int slotNum = projectedSlotMap.IndexOf(member);
requiredSlots[slotNum] = true;
}
// effects: see BoolLiteral.RemapBool
internal override BoolLiteral RemapBool(Dictionary remap) {
JoinTreeSlot newVar = (JoinTreeSlot) Slot.RemapSlot(remap);
return OneOfConst.Factory(newVar, Values, this.GetType() == typeof(OneOfTypeConst));
}
// oneOfConst can be partial
// effects: see BoolLiteral.IsEqualTo
protected override bool IsEqualTo(BoolLiteral right) {
OneOfConst rightOneOfConst = right as OneOfConst;
if (rightOneOfConst == null) {
return false;
}
if (object.ReferenceEquals(this, rightOneOfConst)) {
return true;
}
if (false == JoinTreeSlot.EqualityComparer.Equals(m_slot, rightOneOfConst.m_slot)) {
return false;
}
return m_values.IsEqualTo(rightOneOfConst.m_values);
}
// oneOfConst can be partial
// effects: see BoolLiteral.GetHash
protected override int GetHash() {
int result = JoinTreeSlot.EqualityComparer.GetHashCode(m_slot);
result ^= m_values.GetHash();
return result;
}
// oneOfConst can be partial
// effects: see BoolLiteral.IsIdentifierEqualTo
protected override bool IsIdentifierEqualTo(BoolLiteral right) {
OneOfConst rightOneOfConst = right as OneOfConst;
if (rightOneOfConst == null) {
return false;
}
if (object.ReferenceEquals(this, rightOneOfConst)) {
return true;
}
return JoinTreeSlot.EqualityComparer.Equals(m_slot, rightOneOfConst.m_slot);
}
// oneOfConst can be partial
// effects: see BoolLiteral.GetIdentifierHash
protected override int GetIdentifierHash() {
int result = JoinTreeSlot.EqualityComparer.GetHashCode(m_slot);
return result;
}
#endregion
#region Other Methods
// effects: Converts this to a user-understandable
// string. invertOutput indicates whether the text needs to say "x in
// .. or x in NOT ... (i.e., the latter if invertOutput is true)
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal void ToUserString(bool invertOutput, StringBuilder builder, MetadataWorkspace workspace) {
// If there is a negated cell constant, get the inversion of the domain
NegatedCellConstant negatedConstant = null;
foreach (CellConstant constant in Values.Values) {
negatedConstant = constant as NegatedCellConstant;
if (negatedConstant != null) {
break;
}
}
Set constants;
if (negatedConstant != null) {
// Invert the domain and invert "invertOutput"
invertOutput = !invertOutput;
// Add all the values to negatedConstant's values to get the
// final set of constants
constants = new Set(negatedConstant.Elements, CellConstant.EqualityComparer);
foreach (CellConstant constant in Values.Values) {
if (!(constant is NegatedCellConstant)) {
Debug.Assert(constants.Contains(constant), "Domain of negated constant does not have positive constant");
constants.Remove(constant);
}
}
} else {
constants = new Set(Values.Values, CellConstant.EqualityComparer);
}
// Determine the resource to use
Debug.Assert(constants.Count > 0, "one of const is false?");
bool isNull = constants.Count == 1 && constants.Single().IsNull();
bool isTypeConstant = this is OneOfTypeConst;
Func