Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Entity/System/Data/Objects/ObjectStateManagerMetadata.cs

@@ -0,0 +1,267 @@
+//---------------------------------------------------------------------
+// <copyright file="ObjectStateManagerMetadata.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//
+// @owner       [....]
+// @backupOwner [....]
+//---------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Data.Metadata.Edm;
+using System.Data.Mapping;
+using System.Diagnostics;
+
+namespace System.Data.Objects
+{
+
+    internal struct EntitySetQualifiedType : IEqualityComparer<EntitySetQualifiedType>
+    {
+        internal static readonly IEqualityComparer<EntitySetQualifiedType> EqualityComparer = new EntitySetQualifiedType();        
+        
+        internal readonly Type ClrType;
+        internal readonly EntitySet EntitySet;
+
+        internal EntitySetQualifiedType(Type type, EntitySet set)
+        {
+            Debug.Assert(null != type, "null Type");
+            Debug.Assert(null != set, "null EntitySet");
+            Debug.Assert(null != set.EntityContainer, "null EntityContainer");
+            Debug.Assert(null != set.EntityContainer.Name, "null EntityContainer.Name");
+            ClrType = EntityUtil.GetEntityIdentityType(type);
+            EntitySet = set;
+        }
+
+        public bool Equals(EntitySetQualifiedType x, EntitySetQualifiedType y)
+        {
+            return (Object.ReferenceEquals(x.ClrType, y.ClrType) &&
+                    Object.ReferenceEquals(x.EntitySet, y.EntitySet));
+        }
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2303", Justification="ClrType is not expected to be an Embedded Interop Type.")]
+        public int GetHashCode(EntitySetQualifiedType obj)
+        {
+            return unchecked(obj.ClrType.GetHashCode() +
+                             obj.EntitySet.Name.GetHashCode() +
+                             obj.EntitySet.EntityContainer.Name.GetHashCode());
+        }
+    }
+
+    internal sealed class StateManagerMemberMetadata
+    {
+        private readonly EdmProperty _clrProperty; // may be null if shadowState
+        private readonly EdmProperty _edmProperty;
+        private readonly bool _isPartOfKey;
+        private readonly bool _isComplexType;
+
+        internal StateManagerMemberMetadata(ObjectPropertyMapping memberMap, EdmProperty memberMetadata, bool isPartOfKey)
+        {
+            // if memberMap is null, then this is a shadowstate
+            Debug.Assert(null != memberMap, "shadowstate not supported");
+            Debug.Assert(null != memberMetadata, "CSpace should never be null");
+            _clrProperty = memberMap.ClrProperty;
+            _edmProperty = memberMetadata;
+            _isPartOfKey = isPartOfKey;
+            _isComplexType = (Helper.IsEntityType(_edmProperty.TypeUsage.EdmType) ||
+                             Helper.IsComplexType(_edmProperty.TypeUsage.EdmType));
+        }
+
+        internal string CLayerName
+        {
+            get
+            {
+                return _edmProperty.Name;
+            }
+        }
+
+        internal Type ClrType
+        {
+            get
+            {
+                Debug.Assert(null != _clrProperty, "shadowstate not supported");
+                return _clrProperty.TypeUsage.EdmType.ClrType;
+                //return ((null != _clrProperty)
+                //    ? _clrProperty.TypeUsage.EdmType.ClrType
+                //    : (Helper.IsComplexType(_edmProperty)
+                //        ? typeof(DbDataRecord)
+                //        : ((PrimitiveType)_edmProperty.TypeUsage.EdmType).ClrEquivalentType));
+            }
+        }
+        internal bool IsComplex
+        {
+            get
+            {
+                return _isComplexType;
+            }
+        }
+        internal EdmProperty CdmMetadata
+        {
+            get
+            {
+                return _edmProperty;
+            }
+        }
+        internal EdmProperty ClrMetadata
+        {
+            get
+            {
+                Debug.Assert(null != _clrProperty, "shadowstate not supported");
+                return _clrProperty;
+            }
+        }
+        internal bool IsPartOfKey
+        {
+            get
+            {
+                return _isPartOfKey;
+            }
+        }
+        public object GetValue(object userObject) // wrapp it in cacheentry
+        {
+            Debug.Assert(null != _clrProperty, "shadowstate not supported");
+            object dataObject = LightweightCodeGenerator.GetValue(_clrProperty, userObject);
+            return dataObject;
+        }
+        public void SetValue(object userObject, object value) // if record , unwrapp to object, use materializer in cacheentry
+        {
+            Debug.Assert(null != _clrProperty, "shadowstate not supported");
+            if (DBNull.Value == value)
+            {
+                value = null;
+            }
+            if (IsComplex && value == null)
+            {
+                throw EntityUtil.NullableComplexTypesNotSupported(CLayerName);
+            }
+            LightweightCodeGenerator.SetValue(_clrProperty, userObject, value);
+        }
+    }
+
+    internal sealed class StateManagerTypeMetadata
+    {
+        private readonly TypeUsage _typeUsage; // CSpace
+        private readonly ObjectTypeMapping _ocObjectMap;
+        private readonly StateManagerMemberMetadata[] _members;
+        private readonly Dictionary<string, int> _objectNameToOrdinal;
+        private readonly Dictionary<string, int> _cLayerNameToOrdinal;
+        private readonly DataRecordInfo _recordInfo;
+
+        internal StateManagerTypeMetadata(EdmType edmType, ObjectTypeMapping mapping)
+        {
+            Debug.Assert(null != edmType, "null EdmType");
+            Debug.Assert(Helper.IsEntityType(edmType) ||
+                         Helper.IsComplexType(edmType),
+                         "not Complex or EntityType");
+            Debug.Assert(Object.ReferenceEquals(mapping, null) ||
+                         Object.ReferenceEquals(mapping.EdmType, edmType),
+                         "different EdmType instance");
+
+            _typeUsage = TypeUsage.Create(edmType);
+            _recordInfo = new DataRecordInfo(_typeUsage);
+            _ocObjectMap = mapping;
+
+            ReadOnlyMetadataCollection<EdmProperty> members = TypeHelpers.GetProperties(edmType);
+            _members = new StateManagerMemberMetadata[members.Count];
+            _objectNameToOrdinal = new Dictionary<string, int>(members.Count);
+            _cLayerNameToOrdinal = new Dictionary<string, int>(members.Count);
+
+            ReadOnlyMetadataCollection<EdmMember> keyMembers = null;
+            if (Helper.IsEntityType(edmType))
+            {
+                keyMembers = ((EntityType)edmType).KeyMembers;
+            }
+
+            for (int i = 0; i < _members.Length; ++i)
+            {
+                EdmProperty member = members[i];
+
+                ObjectPropertyMapping memberMap = null;
+                if (null != mapping)
+                {
+                    memberMap = mapping.GetPropertyMap(member.Name);
+                    if (null != memberMap)
+                    {
+                        _objectNameToOrdinal.Add(memberMap.ClrProperty.Name, i); // olayer name
+                    }
+                }
+                _cLayerNameToOrdinal.Add(member.Name, i); // clayer name
+
+                // Determine whether this member is part of the identity of the entity.
+                _members[i] = new StateManagerMemberMetadata(memberMap, member, ((null != keyMembers) && keyMembers.Contains(member)));
+            }
+        }
+
+        internal TypeUsage CdmMetadata
+        {
+            get
+            {
+                return _typeUsage;
+            }
+        }
+        internal DataRecordInfo DataRecordInfo
+        {
+            get { return _recordInfo; }
+        }
+
+        internal int FieldCount
+        {
+            get
+            {
+                return _members.Length;
+            }
+        }
+
+        internal Type GetFieldType(int ordinal)
+        {
+            return Member(ordinal).ClrType;
+        }
+
+        internal StateManagerMemberMetadata Member(int ordinal)
+        {
+            if (unchecked((uint)ordinal < (uint)_members.Length))
+            {
+                return _members[ordinal];
+            }
+            throw EntityUtil.ArgumentOutOfRange("ordinal");
+        }
+
+        internal IEnumerable<StateManagerMemberMetadata> Members
+        {
+            get { return _members; }
+        }
+
+        internal string CLayerMemberName(int ordinal)
+        {
+            return Member(ordinal).CLayerName;
+        }
+        internal int GetOrdinalforOLayerMemberName(string name)
+        {
+            int ordinal;
+            if (String.IsNullOrEmpty(name) || !_objectNameToOrdinal.TryGetValue(name, out ordinal))
+            {
+                ordinal = -1;
+            }
+            return ordinal;
+        }
+        internal int GetOrdinalforCLayerMemberName(string name)
+        {
+            int ordinal;
+            if (String.IsNullOrEmpty(name) || !_cLayerNameToOrdinal.TryGetValue(name, out ordinal))
+            {
+                ordinal = -1;
+            }
+            return ordinal;
+        }
+        internal bool IsMemberPartofShadowState(int ordinal)
+        {
+            // 
+
+
+            Debug.Assert(Member(ordinal) != null,
+                "The only case where Member(ordinal) can be null is if the property is in shadow state.  " +
+                "When shadow state support is added, this assert should never fire.");
+            return (null == Member(ordinal).ClrMetadata);
+        }
+    }
+}