|
//---------------------------------------------------------------------
// <copyright file="MemberPath.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------
using System;
using System.Data.Common.CommandTrees;
using System.Data.Common.CommandTrees.ExpressionBuilder;
using System.Data.Common.Utils;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Data.Mapping.ViewGeneration.CqlGeneration;
using System.Data.Metadata.Edm;
using System.Linq;
namespace System.Data.Mapping.ViewGeneration.Structures
{
/// <summary>
/// A class that corresponds to a path in some extent, e.g., Person, Person.addr, Person.addr.state
/// Empty path represents path to the extent.
/// </summary>
internal sealed class MemberPath : InternalBase, IEquatable<MemberPath>
{
#region Fields
/// <summary>
/// The base entity set.
/// </summary>
private readonly EntitySetBase m_extent;
/// <summary>
/// List of members in the path.
/// </summary>
private readonly List<EdmMember> m_path;
internal static readonly IEqualityComparer<MemberPath> EqualityComparer = new Comparer();
#endregion
#region Constructors
/// <summary>
/// Creates a member path that corresponds to <paramref name="path"/> in the <paramref name="extent"/> (or the extent itself).
/// </summary>
internal MemberPath(EntitySetBase extent, IEnumerable<EdmMember> path)
{
m_extent = extent;
m_path = path.ToList();
}
/// <summary>
/// Creates a member path that corresponds to the <paramref name="extent"/>.
/// </summary>
internal MemberPath(EntitySetBase extent)
: this(extent, Enumerable.Empty<EdmMember>())
{ }
/// <summary>
/// Creates a path corresponding to <paramref name="extent"/>.<paramref name="member"/>
/// </summary>
internal MemberPath(EntitySetBase extent, EdmMember member)
: this(extent, Enumerable.Repeat<EdmMember>(member, 1))
{ }
/// <summary>
/// Creates a member path corresponding to the path <paramref name="prefix"/>.<paramref name="last"/>
/// </summary>
internal MemberPath(MemberPath prefix, EdmMember last)
{
m_extent = prefix.m_extent;
m_path = new List<EdmMember>(prefix.m_path);
m_path.Add(last);
}
#endregion
#region Properties
/// <summary>
/// Returns the first path item in a non-empty path, otherwise null.
/// </summary>
internal EdmMember RootEdmMember
{
get { return m_path.Count > 0 ? m_path[0] : null; }
}
/// <summary>
/// Returns the last path item in a non-empty path, otherwise null.
/// </summary>
internal EdmMember LeafEdmMember
{
get { return m_path.Count > 0 ? m_path[m_path.Count - 1] : null; }
}
/// <summary>
/// For non-empty paths returns name of the last path item, otherwise returns name of <see cref="Extent"/>.
/// </summary>
internal string LeafName
{
get
{
if (m_path.Count == 0)
{
return m_extent.Name;
}
else
{
return LeafEdmMember.Name;
}
}
}
/// <summary>
/// Tells path represents a computed slot.
/// </summary>
internal bool IsComputed
{
get
{
if (m_path.Count == 0)
{
return false;
}
else
{
return RootEdmMember.IsStoreGeneratedComputed;
}
}
}
/// <summary>
/// Returns the default value the slot represented by the path. If no default value is present, returns null.
/// </summary>
internal object DefaultValue
{
get
{
if (m_path.Count == 0)
{
return null;
}
Facet facet;
if (LeafEdmMember.TypeUsage.Facets.TryGetValue(EdmProviderManifest.DefaultValueFacetName, false, out facet))
{
return facet.Value;
}
return null;
}
}
/// <summary>
/// Returns true if slot represented by the path is part of a key.
/// </summary>
internal bool IsPartOfKey
{
get
{
if (m_path.Count == 0)
{
return false;
}
return MetadataHelper.IsPartOfEntityTypeKey(LeafEdmMember);
}
}
/// <summary>
/// Returns true if slot represented by the path is nullable.
/// </summary>
internal bool IsNullable
{
get
{
if (m_path.Count == 0)
{
return false;
}
return MetadataHelper.IsMemberNullable(LeafEdmMember);
}
}
/// <summary>
/// If path corresponds to an entity set (empty path) or an association end (<see cref="Extent"/> is as association set, and path length is 1),
/// returns <see cref="EntitySet"/> associated with the value of the slot represented by this path, otherwise returns null.
/// </summary>
internal EntitySet EntitySet
{
get
{
if (m_path.Count == 0)
{
return m_extent as EntitySet;
}
else if (m_path.Count == 1)
{
AssociationEndMember endMember = this.RootEdmMember as AssociationEndMember;
if (endMember != null)
{
EntitySet result = MetadataHelper.GetEntitySetAtEnd((AssociationSet)m_extent, endMember);
return result;
}
}
return null;
}
}
/// <summary>
/// Extent of the path.
/// </summary>
internal EntitySetBase Extent
{
get { return m_extent; }
}
/// <summary>
/// Returns the type of attribute denoted by the path.
/// For example, member type of Person.addr.zip would be integer. For extent, it is the element type.
/// </summary>
internal EdmType EdmType
{
get
{
if (m_path.Count > 0)
{
return LeafEdmMember.TypeUsage.EdmType;
}
else
{
return m_extent.ElementType;
}
}
}
/// <summary>
/// Returns Cql field alias generated from the path items.
/// </summary>
internal string CqlFieldAlias
{
get
{
string alias = PathToString(true);
if (false == alias.Contains("_"))
{
// if alias of the member does not contain any "_", we can replace "." with "_" so that we can get a simple identifier.
alias = alias.Replace('.', '_');
}
StringBuilder builder = new StringBuilder();
CqlWriter.AppendEscapedName(builder, alias);
return builder.ToString();
}
}
#endregion
#region Methods
/// <summary>
/// Returns false iff the path is
/// * A descendant of some nullable property
/// * A descendant of an optional composition/collection
/// * A descendant of a property that does not belong to the basetype/rootype of its parent.
/// </summary>
internal bool IsAlwaysDefined(Dictionary<EntityType, Set<EntityType>> inheritanceGraph)
{
if (m_path.Count == 0)
{
// Extents are always defined
return true;
}
EdmMember member = m_path.Last();
//Dont check last member, thats the property we are testing
for (int i = 0; i < m_path.Count - 1; i++)
{
EdmMember current = m_path[i];
// If member is nullable then "this" will not always be defined
if (MetadataHelper.IsMemberNullable(current))
{
return false;
}
}
//Now check if there are any concrete types other than all subtypes of Type defining this member
//by definition association types member are always present since they are IDs
if (m_path[0].DeclaringType is AssociationType)
{
return true;
}
EntityType entitySetType = m_extent.ElementType as EntityType;
if (entitySetType == null) //association type
{
return true;
}
//well, we handle the first case because we don't knwo how to get to subtype (i.e. the edge to avoid)
EntityType memberDeclaringType = m_path[0].DeclaringType as EntityType;
EntityType parentType = memberDeclaringType.BaseType as EntityType;
if (entitySetType.EdmEquals(memberDeclaringType) || MetadataHelper.IsParentOf(memberDeclaringType, entitySetType) || parentType == null)
{
return true;
}
else if (!parentType.Abstract && !MetadataHelper.DoesMemberExist(parentType, member))
{
return false;
}
bool result = !RecurseToFindMemberAbsentInConcreteType(parentType, memberDeclaringType, member, entitySetType, inheritanceGraph);
return result;
}
private static bool RecurseToFindMemberAbsentInConcreteType(EntityType current, EntityType avoidEdge, EdmMember member, EntityType entitySetType, Dictionary<EntityType, Set<EntityType>> inheritanceGraph)
{
Set<EntityType> edges = inheritanceGraph[current];
//for each outgoing edge (from current) where the edge is not the one to avoid,
// navigate depth-first
foreach (var edge in edges.Where(type => !type.EdmEquals(avoidEdge)))
{
//Dont traverse above the EntitySet's Element type
if (entitySetType.BaseType != null && entitySetType.BaseType.EdmEquals(edge))
{
continue;
}
if (!edge.Abstract && !MetadataHelper.DoesMemberExist(edge, member))
{
//found it.. I'm the concrete type that has member absent.
return true;
}
if (RecurseToFindMemberAbsentInConcreteType(edge, current /*avoid traversing down back here*/, member, entitySetType, inheritanceGraph))
{
//one of the edges reachable from me found it
return true;
}
}
//no body found this counter example
return false;
}
/// <summary>
/// Determines all the identifiers used in the path and adds them to <paramref name="identifiers"/>.
/// </summary>
internal void GetIdentifiers(CqlIdentifiers identifiers)
{
// Get the extent name and extent type name
identifiers.AddIdentifier(m_extent.Name);
identifiers.AddIdentifier(m_extent.ElementType.Name);
foreach (EdmMember member in m_path)
{
identifiers.AddIdentifier(member.Name);
}
}
/// <summary>
/// Returns true iff all members are nullable properties, i.e., if even one of them is non-nullable, returns false.
/// </summary>
internal static bool AreAllMembersNullable(IEnumerable<MemberPath> members)
{
foreach (MemberPath path in members)
{
if (path.m_path.Count == 0)
{
return false; // Extents are not nullable
}
if (path.IsNullable == false)
{
return false;
}
}
return true;
}
/// <summary>
/// Returns a string that has the list of properties in <paramref name="members"/> (i.e., just the last name) if <paramref name="fullPath"/> is false.
/// Else the <paramref name="fullPath"/> is added.
/// </summary>
internal static string PropertiesToUserString(IEnumerable<MemberPath> members, bool fullPath)
{
bool isFirst = true;
StringBuilder builder = new StringBuilder();
foreach (MemberPath path in members)
{
if (isFirst == false)
{
builder.Append(", ");
}
isFirst = false;
if (fullPath)
{
builder.Append(path.PathToString(false));
}
else
{
builder.Append(path.LeafName);
}
}
return builder.ToString();
}
/// <summary>
/// Given a member path and an alias, returns an eSQL string correspondng to the fully-qualified name <paramref name="blockAlias"/>.path, e.g., T1.Address.Phone.Zip.
/// If a subcomponent belongs to subclass, generates a treat for it, e.g. "TREAT(T1 as Customer).Address".
/// Or even "TREAT(TREAT(T1 AS Customer).Address as USAddress).Zip".
/// </summary>
internal StringBuilder AsEsql(StringBuilder inputBuilder, string blockAlias)
{
// Due to the TREAT stuff, we cannot build incrementally.
// So we use a local StringBuilder - it should not be that inefficient (one extra copy).
StringBuilder builder = new StringBuilder();
// Add blockAlias as a starting point for blockAlias.member1.member2...
CqlWriter.AppendEscapedName(builder, blockAlias);
// Process all items in the path.
AsCql(
// accessMember action
(memberName) =>
{
builder.Append('.');
CqlWriter.AppendEscapedName(builder, memberName);
},
// getKey action
() =>
{
builder.Insert(0, "Key(");
builder.Append(")");
},
// treatAs action
(treatAsType) =>
{
builder.Insert(0, "TREAT(");
builder.Append(" AS ");
CqlWriter.AppendEscapedTypeName(builder, treatAsType);
builder.Append(')');
});
inputBuilder.Append(builder.ToString());
return inputBuilder;
}
internal DbExpression AsCqt(DbExpression row)
{
DbExpression cqt = row;
// Process all items in the path.
AsCql(
// accessMember action
(memberName) =>
{
cqt = DbExpressionBuilder.Property(cqt, memberName);
},
// getKey action
() =>
{
cqt = cqt.GetRefKey();
},
// treatAs action
(treatAsType) =>
{
var typeUsage = TypeUsage.Create(treatAsType);
cqt = cqt.TreatAs(typeUsage);
});
return cqt;
}
internal void AsCql(Action<string> accessMember, Action getKey, Action<StructuralType> treatAs)
{
// Keep track of the previous type so that we can determine if we need to cast or not.
EdmType prevType = m_extent.ElementType;
foreach (EdmMember member in m_path)
{
// If prevType is a ref (e.g., ref to CPerson), we need to get the type that it is pointing to and then look for this member in that type.
StructuralType prevStructuralType;
RefType prevRefType;
if (Helper.IsRefType(prevType))
{
prevRefType = (RefType)prevType;
prevStructuralType = prevRefType.ElementType;
}
else
{
prevRefType = null;
prevStructuralType = (StructuralType)prevType;
}
// Check whether the prevType has the present member in it.
// If not, we will need to cast the prev type to the appropriate subtype.
bool found = MetadataHelper.DoesMemberExist(prevStructuralType, member);
if (prevRefType != null)
{
// For reference types, the key must be present in the element type itself.
// E.g., if we have Ref(CPerson), the key must be present as CPerson.pid or CPerson.Address.Phone.Number (i.e., in a complex type).
// Note that it cannot be present in the subtype of address or phone either, i.e., this path better not have any TREATs.
// We are at CPerson right now. So if we say Key(CPerson), we will get a row with all the key elements.
// Then we can continue going down the path in CPerson
Debug.Assert(found == true, "We did not find the key property in a ref's element type - it cannot be in a subtype");
Debug.Assert(MetadataHelper.IsPartOfEntityTypeKey(member), "Member is expected to be a key property");
// Emit KEY(current path segment)
getKey();
}
else if (false == found)
{
// Need to add Treat(... as ...) expression in the beginning.
// Note that it does handle cases like TREAT(TREAT(T1 AS Customer).Address as USAddress).Zip
Debug.Assert(prevRefType == null, "We do not allow subtyping in key extraction from Refs");
// Emit TREAT(current path segment as member.DeclaringType)
treatAs(member.DeclaringType);
}
// Add the member's access. We had a path "T1.A.B" till now.
accessMember(member.Name);
prevType = member.TypeUsage.EdmType;
}
}
public bool Equals(MemberPath right)
{
return EqualityComparer.Equals(this, right);
}
public override bool Equals(object obj)
{
MemberPath right = obj as MemberPath;
if (obj == null)
{
return false;
}
return Equals(right);
}
public override int GetHashCode()
{
return EqualityComparer.GetHashCode(this);
}
/// <summary>
/// Returns true if the member denoted by the path corresponds to a scalar (primitive or enum).
/// </summary>
internal bool IsScalarType()
{
return this.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType ||
this.EdmType.BuiltInTypeKind == BuiltInTypeKind.EnumType;
}
internal static IEnumerable<MemberPath> GetKeyMembers(EntitySetBase extent, MemberDomainMap domainMap)
{
MemberPath extentPath = new MemberPath(extent);
List<MemberPath> keyAttributes = new List<MemberPath>(
extentPath.GetMembers(extentPath.Extent.ElementType, null /* isScalar */, null /* isConditional */, true /* isPartOfKey */, domainMap));
Debug.Assert(keyAttributes.Any(), "No key attributes?");
return keyAttributes;
}
internal IEnumerable<MemberPath> GetMembers(EdmType edmType, bool? isScalar, bool? isConditional, bool? isPartOfKey, MemberDomainMap domainMap)
{
MemberPath currentPath = this;
StructuralType structuralType = (StructuralType)edmType;
foreach (EdmMember edmMember in structuralType.Members)
{
if (edmMember is AssociationEndMember)
{
// get end's keys
foreach (MemberPath endKey in new MemberPath(currentPath, edmMember).GetMembers(
((RefType)edmMember.TypeUsage.EdmType).ElementType,
isScalar, isConditional, true /*isPartOfKey*/, domainMap))
{
yield return endKey;
}
}
bool isActuallyScalar = MetadataHelper.IsNonRefSimpleMember(edmMember);
if (isScalar == null || isScalar == isActuallyScalar)
{
EdmProperty childProperty = edmMember as EdmProperty;
if (childProperty != null)
{
bool isActuallyKey = MetadataHelper.IsPartOfEntityTypeKey(childProperty);
if (isPartOfKey == null || isPartOfKey == isActuallyKey)
{
MemberPath childPath = new MemberPath(currentPath, childProperty);
bool isActuallyConditional = domainMap.IsConditionMember(childPath);
if (isConditional == null || isConditional == isActuallyConditional)
{
yield return childPath;
}
}
}
}
}
}
/// <summary>
/// Returns true if this path and <paramref name="path1"/> are equivalent on the C-side via a referential constraint.
/// </summary>
internal bool IsEquivalentViaRefConstraint(MemberPath path1)
{
MemberPath path0 = this;
// Now check if they are equivalent via referential constraint
// For example,
// * Person.pid and PersonAddress.Person.pid are equivalent
// * Person.pid and PersonAddress.Address.pid are equivalent
// * Person.pid and Address.pid are equivalent if there is a referential constraint
// * PersonAddress.Person.pid and PersonAddress.Address.pid are
// equivalent if there is a referential constraint
// In short, Person.pid, Address.pid, PersonAddress.Address.pid,
// PersonAddress.Person.pid are the same
if (path0.EdmType is EntityTypeBase || path1.EdmType is EntityTypeBase ||
MetadataHelper.IsNonRefSimpleMember(path0.LeafEdmMember) == false ||
MetadataHelper.IsNonRefSimpleMember(path1.LeafEdmMember) == false)
{
// If the path corresponds to a top level extent only, ignore
// it. Or if it is not a scalar
return false;
}
AssociationSet assocSet0 = path0.Extent as AssociationSet;
AssociationSet assocSet1 = path1.Extent as AssociationSet;
EntitySet entitySet0 = path0.Extent as EntitySet;
EntitySet entitySet1 = path1.Extent as EntitySet;
bool result = false;
if (assocSet0 != null && assocSet1 != null)
{
// PersonAddress.Person.pid and PersonAddress.Address.pid case
// Check if they are the same association or not
if (assocSet0.Equals(assocSet1) == false)
{
return false;
}
result = AreAssocationEndPathsEquivalentViaRefConstraint(path0, path1, assocSet0);
}
else if (entitySet0 != null && entitySet1 != null)
{
// Person.pid, Address.pid case
// Find all the associations between the two sets. If the
// fields are equivalent via any association + referential
// constraint, return true
List<AssociationSet> assocSets = MetadataHelper.GetAssociationsForEntitySets(entitySet0, entitySet1);
foreach (AssociationSet assocSet in assocSets)
{
// For Person.pid, get PersonAddress.Person.pid or
MemberPath assocEndPath0 = path0.GetCorrespondingAssociationPath(assocSet);
MemberPath assocEndPath1 = path1.GetCorrespondingAssociationPath(assocSet);
if (AreAssocationEndPathsEquivalentViaRefConstraint(assocEndPath0, assocEndPath1, assocSet))
{
result = true;
break;
}
}
}
else
{
// One of them is an assocSet and the other is an entity set
AssociationSet assocSet = assocSet0 != null ? assocSet0 : assocSet1;
EntitySet entitySet = entitySet0 != null ? entitySet0 : entitySet1;
Debug.Assert(assocSet != null && entitySet != null,
"One set must be association and the other must be entity set");
MemberPath assocEndPathA = path0.Extent is AssociationSet ? path0 : path1;
MemberPath entityPath = path0.Extent is EntitySet ? path0 : path1;
MemberPath assocEndPathB = entityPath.GetCorrespondingAssociationPath(assocSet);
if (assocEndPathB == null)
{
//An EntitySet might participate in multiple AssociationSets
//and this might not be the association set that defines the expected referential
//constraint
//Return false since this does not have any referential constraint specified
result = false;
}
else
{
result = AreAssocationEndPathsEquivalentViaRefConstraint(assocEndPathA, assocEndPathB, assocSet);
}
}
return result;
}
/// <summary>
/// Returns true if <paramref name="assocPath0"/> and <paramref name="assocPath1"/> are equivalent via a referential constraint in <paramref name="assocSet"/>.
/// Requires: <paramref name="assocPath0"/> and <paramref name="assocPath1"/> correspond to paths in <paramref name="assocSet"/>.
/// </summary>
private static bool AreAssocationEndPathsEquivalentViaRefConstraint(MemberPath assocPath0,
MemberPath assocPath1,
AssociationSet assocSet)
{
Debug.Assert(assocPath0.Extent.Equals(assocSet) && assocPath1.Extent.Equals(assocSet),
"Extent for paths must be assocSet");
AssociationEndMember end0 = assocPath0.RootEdmMember as AssociationEndMember;
AssociationEndMember end1 = assocPath1.RootEdmMember as AssociationEndMember;
EdmProperty property0 = assocPath0.LeafEdmMember as EdmProperty;
EdmProperty property1 = assocPath1.LeafEdmMember as EdmProperty;
if (end0 == null || end1 == null || property0 == null || property1 == null)
{
return false;
}
// Now check if these fields are connected via a referential constraint
AssociationType assocType = assocSet.ElementType;
bool foundConstraint = false;
foreach (ReferentialConstraint constraint in assocType.ReferentialConstraints)
{
bool isFrom0 = end0.Name == constraint.FromRole.Name &&
end1.Name == constraint.ToRole.Name;
bool isFrom1 = end1.Name == constraint.FromRole.Name &&
end0.Name == constraint.ToRole.Name;
if (isFrom0 || isFrom1)
{
// Found an RI for the two sets. Make sure that the properties are at the same ordinal
// isFrom0 is true when end0 corresponds to FromRole and end1 to ToRole
ReadOnlyMetadataCollection<EdmProperty> properties0 = isFrom0 ? constraint.FromProperties : constraint.ToProperties;
ReadOnlyMetadataCollection<EdmProperty> properties1 = isFrom0 ? constraint.ToProperties : constraint.FromProperties;
int indexForPath0 = properties0.IndexOf(property0);
int indexForPath1 = properties1.IndexOf(property1);
if (indexForPath0 == indexForPath1 && indexForPath0 != -1)
{
foundConstraint = true;
break;
}
}
}
return foundConstraint;
}
/// <summary>
/// Returns the member path corresponding to that field in the <paramref name="assocSet"/>. E.g., given Address.pid, returns PersonAddress.Address.pid.
/// For self-associations, such as ManagerEmployee with referential constraints (and we have
/// [ManagerEmployee.Employee.mid, ManagerEmployee.Employee.eid, ManagerEmployee.Manager.mid]), given Employee.mid, returns
/// ManagerEmployee.Employee.mid or ManagerEmployee.Manager.mid
///
/// Note: the path need not correspond to a key field of an entity set <see cref="Extent"/>.
/// </summary>
private MemberPath GetCorrespondingAssociationPath(AssociationSet assocSet)
{
Debug.Assert(this.Extent is EntitySet, "path must be in the context of an entity set");
// Find the end corresponding to the entity set
AssociationEndMember end = MetadataHelper.GetSomeEndForEntitySet(assocSet, (EntitySet)m_extent);
// An EntitySet might participate in multiple AssociationSets and
// this might not be the association set that defines the expected referential constraint.
if (end == null)
{
return null;
}
// Create the new members using the end
List<EdmMember> newMembers = new List<EdmMember>();
newMembers.Add(end);
newMembers.AddRange(m_path);
// The extent is the assocSet
MemberPath result = new MemberPath(assocSet, newMembers);
return result;
}
/// <summary>
/// If member path identifies a relationship end, return its scope. Otherwise, returns null.
/// </summary>
internal EntitySet GetScopeOfRelationEnd()
{
if (m_path.Count == 0)
{
return null;
}
AssociationEndMember relationEndMember = LeafEdmMember as AssociationEndMember;
if (relationEndMember == null)
{
return null;
}
// Yes, it's a reference, determine its entity set refScope
AssociationSet associationSet = (AssociationSet)m_extent;
EntitySet result = MetadataHelper.GetEntitySetAtEnd(associationSet, relationEndMember);
return result;
}
/// <summary>
/// Returns a string of the form "a.b.c" that corresponds to the items in the path. This string can be used for tests or localization.
/// If <paramref name="forAlias"/>=true, we return a string that is relevant for Cql aliases, else we return the exact path.
/// </summary>
internal string PathToString(bool? forAlias)
{
StringBuilder builder = new StringBuilder();
if (forAlias != null)
{
if (forAlias == true)
{
// For the 0th entry, we just choose the type of the element in
// which the first entry belongs, e.g., if Addr belongs to CCustomer,
// we choose CCustomer and not CPerson.
if (m_path.Count == 0)
{
EntityTypeBase type = m_extent.ElementType;
return type.Name;
}
builder.Append(m_path[0].DeclaringType.Name); // Get CCustomer here
}
else
{
// Append the extent name
builder.Append(m_extent.Name);
}
}
// Just join the path using "."
for (int i = 0; i < m_path.Count; i++)
{
builder.Append('.');
builder.Append(m_path[i].Name);
}
return builder.ToString();
}
/// <summary>
/// Returns a human-readable string corresponding to the path.
/// </summary>
internal override void ToCompactString(StringBuilder builder)
{
builder.Append(PathToString(false));
}
internal void ToCompactString(StringBuilder builder, string instanceToken)
{
builder.Append(instanceToken + PathToString(null));
}
#endregion
#region Comparer
private sealed class Comparer : IEqualityComparer<MemberPath>
{
public bool Equals(MemberPath left, MemberPath right)
{
if (object.ReferenceEquals(left, right))
{
return true;
}
// One of them is non-null at least. So if the other one is
// null, we cannot be equal
if (left == null || right == null)
{
return false;
}
// Both are non-null at this point
// Checks that the paths are equal component-wise
if (left.m_extent.Equals(right.m_extent) == false || left.m_path.Count != right.m_path.Count)
{
return false;
}
for (int i = 0; i < left.m_path.Count; i++)
{
// Comparing MemberMetadata -- can use Equals
if (false == left.m_path[i].Equals(right.m_path[i]))
{
return false;
}
}
return true;
}
public int GetHashCode(MemberPath key)
{
int result = key.m_extent.GetHashCode();
foreach (EdmMember member in key.m_path)
{
result ^= member.GetHashCode();
}
return result;
}
}
#endregion
}
}
|