internal bool TryGetEnumMember(EnumType type, String memberName, bool ignoreCase, out EnumMember outMember) { EntityUtil.CheckArgumentNull(type, "type"); EntityUtil.CheckStringArgument(memberName, "memberName"); outMember = null; return type.Members.TryGetValue(memberName, ignoreCase, out outMember); }
internal virtual bool TryGetEnumMember(EnumType type, String memberName, bool ignoreCase, out EnumMember outMember) { //Contract.Requires(type != null); EntityUtil.CheckStringArgument(memberName, "memberName"); outMember = null; return type.Members.TryGetValue(memberName, ignoreCase, out outMember); }
static Converter() { Debug.Assert(Enum.GetUnderlyingType(typeof(ConcurrencyMode)) == typeof(int), "Please update underlying type below accordingly."); // Create the enum types that we will need var concurrencyModeType = new EnumType( EdmProviderManifest.ConcurrencyModeFacetName, EdmConstants.EdmNamespace, underlyingType: PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), isFlags: false, dataSpace: DataSpace.CSpace); foreach (var name in Enum.GetNames(typeof(ConcurrencyMode))) { concurrencyModeType.AddMember( new EnumMember( name, (int)Enum.Parse(typeof(ConcurrencyMode), name, false))); } Debug.Assert( Enum.GetUnderlyingType(typeof(StoreGeneratedPattern)) == typeof(int), "Please update underlying type below accordingly."); var storeGeneratedPatternType = new EnumType( EdmProviderManifest.StoreGeneratedPatternFacetName, EdmConstants.EdmNamespace, underlyingType: PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), isFlags: false, dataSpace: DataSpace.CSpace); foreach (var name in Enum.GetNames(typeof(StoreGeneratedPattern))) { storeGeneratedPatternType.AddMember( new EnumMember( name, (int)Enum.Parse(typeof(StoreGeneratedPattern), name, false))); } // Now create the facet description objects ConcurrencyModeFacet = new FacetDescription( EdmProviderManifest.ConcurrencyModeFacetName, concurrencyModeType, null, null, ConcurrencyMode.None); StoreGeneratedPatternFacet = new FacetDescription( EdmProviderManifest.StoreGeneratedPatternFacetName, storeGeneratedPatternType, null, null, StoreGeneratedPattern.None); CollationFacet = new FacetDescription( DbProviderManifest.CollationFacetName, MetadataItem.EdmProviderManifest.GetPrimitiveType(PrimitiveTypeKind.String), null, null, string.Empty); }
/// <summary> /// Converts SchemaEnumType instance to Metadata EnumType. /// </summary> /// <param name="somEnumType">SchemaEnumType to be covnerted.</param> /// <param name="newGlobalItems">Global item objects where newly created Metadata EnumType will be added.</param> /// <returns></returns> private static EnumType ConvertToEnumType(Som.SchemaEnumType somEnumType, Dictionary<Som.SchemaElement, GlobalItem> newGlobalItems) { Debug.Assert(somEnumType != null, "somEnumType != null"); Debug.Assert(newGlobalItems != null, "newGlobalItems != null"); Debug.Assert(somEnumType.UnderlyingType is Som.ScalarType, "At this point the underlying type should have already been validated and should be ScalarType"); Som.ScalarType enumUnderlyingType = (Som.ScalarType)somEnumType.UnderlyingType; // note that enums don't live in SSpace so there is no need to GetDataSpace() for it. EnumType enumType = new EnumType(somEnumType.Name, somEnumType.Namespace, enumUnderlyingType.Type, somEnumType.IsFlags, DataSpace.CSpace); Type clrEnumUnderlyingType = enumUnderlyingType.Type.ClrEquivalentType; foreach (var somEnumMember in somEnumType.EnumMembers) { Debug.Assert(somEnumMember.Value != null, "value must not be null at this point"); var enumMember = new EnumMember(somEnumMember.Name, Convert.ChangeType(somEnumMember.Value, clrEnumUnderlyingType, CultureInfo.InvariantCulture)); if (somEnumMember.Documentation != null) { enumMember.Documentation = ConvertToDocumentation(somEnumMember.Documentation); } AddOtherContent(somEnumMember, enumMember); enumType.AddMember(enumMember); } if (somEnumType.Documentation != null) { enumType.Documentation = ConvertToDocumentation(somEnumType.Documentation); } AddOtherContent(somEnumType, enumType); newGlobalItems.Add(somEnumType, enumType); return enumType; }
/// <summary> /// Verifies whether enum members of CLR and EDM types match. /// </summary> /// <param name="enumType">OSpace CLR enum type.</param> /// <param name="cspaceEnumType">CSpace EDM enum type.</param> /// <returns><c>true</c> if members match. <c>false</c> otherwise.</returns> private bool EnumMembersMatch(Type enumType, EnumType cspaceEnumType) { Debug.Assert(enumType != null, "enumType != null"); Debug.Assert(enumType.IsEnum, "expected enum OSpace type"); Debug.Assert(cspaceEnumType != null, "cspaceEnumType != null"); Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected"); Debug.Assert(cspaceEnumType.UnderlyingType.ClrEquivalentType == enumType.GetEnumUnderlyingType(), "underlying types should have already been checked"); var enumUnderlyingType = enumType.GetEnumUnderlyingType(); var cspaceSortedEnumMemberEnumerator = cspaceEnumType.Members.OrderBy(m => m.Name).GetEnumerator(); var ospaceSortedEnumMemberNamesEnumerator = enumType.GetEnumNames().OrderBy(n => n).GetEnumerator(); // no checks required if edm enum type does not have any members if (!cspaceSortedEnumMemberEnumerator.MoveNext()) { return true; } while (ospaceSortedEnumMemberNamesEnumerator.MoveNext()) { if (cspaceSortedEnumMemberEnumerator.Current.Name == ospaceSortedEnumMemberNamesEnumerator.Current && cspaceSortedEnumMemberEnumerator.Current.Value.Equals( Convert.ChangeType( Enum.Parse(enumType, ospaceSortedEnumMemberNamesEnumerator.Current), enumUnderlyingType, CultureInfo.InvariantCulture))) { if (!cspaceSortedEnumMemberEnumerator.MoveNext()) { return true; } } } SessionData.LoadMessageLogger.LogLoadMessage( System.Data.Entity.Strings.Mapping_Enum_OCMapping_MemberMismatch( enumType.FullName, cspaceSortedEnumMemberEnumerator.Current.Name, cspaceSortedEnumMemberEnumerator.Current.Value, cspaceEnumType.FullName), cspaceEnumType); return false; }
/// <summary> /// Verifies whether underlying types of CLR and EDM types match /// </summary> /// <param name="enumType">OSpace CLR enum type.</param> /// <param name="cspaceEnumType">CSpace EDM enum type.</param> /// <returns><c>true</c> if types match. <c>false</c> otherwise.</returns> private bool UnderlyingEnumTypesMatch(Type enumType, EnumType cspaceEnumType) { Debug.Assert(enumType != null, "enumType != null"); Debug.Assert(enumType.IsEnum, "expected enum OSpace type"); Debug.Assert(cspaceEnumType != null, "cspaceEnumType != null"); Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected"); // Note that TryGetPrimitiveType() will return false not only for types that are not primitive // but also for CLR primitive types that are valid underlying enum types in CLR but are not // a valid Edm primitive types (e.g. ulong) PrimitiveType underlyingEnumType; if (!ClrProviderManifest.Instance.TryGetPrimitiveType(enumType.GetEnumUnderlyingType(), out underlyingEnumType)) { SessionData.LoadMessageLogger.LogLoadMessage( Strings.Validator_UnsupportedEnumUnderlyingType(enumType.GetEnumUnderlyingType().FullName), cspaceEnumType); return false; } else if (underlyingEnumType.PrimitiveTypeKind != cspaceEnumType.UnderlyingType.PrimitiveTypeKind) { SessionData.LoadMessageLogger.LogLoadMessage( Strings.Validator_OSpace_Convention_NonMatchingUnderlyingTypes, cspaceEnumType); return false; } return true; }
/// <summary> /// Creates new enum OSpace type built based on CLR <paramref name="enumType"/> and <paramref name="cspaceEnumType"/> /// </summary> /// <param name="enumType">CLR type to create OSpace type from.</param> /// <param name="cspaceEnumType">CSpace type used to get namespace and name for the newly created OSpace type.</param> /// <param name="newOSpaceType"> /// New enum OSpace type built based on CLR <paramref name="enumType"/> and <paramref name="cspaceEnumType"/> or null /// if the type could not be built. /// </param> /// <returns><c>true</c> if the type was built successfully.<c>false</c> otherwise.</returns> private bool TryCreateEnumType(Type enumType, EnumType cspaceEnumType, out EdmType newOSpaceType) { Debug.Assert(enumType != null, "enumType != null"); Debug.Assert(enumType.IsEnum, "enum type expected"); Debug.Assert(cspaceEnumType != null, "cspaceEnumType != null"); Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected"); Debug.Assert(TypesMatchByConvention(enumType, cspaceEnumType), "The types passed as parameters don't match by convention."); newOSpaceType = null; // Check if the OSpace and CSpace enum type match if (!UnderlyingEnumTypesMatch(enumType, cspaceEnumType) || !EnumMembersMatch(enumType, cspaceEnumType)) { return false; } newOSpaceType = new ClrEnumType(enumType, cspaceEnumType.NamespaceName, cspaceEnumType.Name); SessionData.TypesInLoading.Add(enumType.FullName, newOSpaceType); return true; }
protected override void Visit(EnumType enumType) { int index; if (!this.AddObjectToSeenListAndHashBuilder(enumType, out index)) { return; } this.AddObjectStartDumpToHashBuilder(enumType, index); this.AddObjectContentToHashBuilder(enumType.Identity); this.Visit(enumType.UnderlyingType); base.Visit(enumType); this.AddObjectEndDumpToHashBuilder(); }
protected virtual void Visit(EnumType enumType) { foreach (var member in enumType.Members) { Visit(member); } }
/// <summary> /// Validates whether CSpace enum type and OSpace enum type match. /// </summary> /// <param name="edmEnumType">CSpace enum type.</param> /// <param name="objectEnumType">OSpace enum type.</param> private static void ValidateEnumTypeMapping(EnumType edmEnumType, EnumType objectEnumType) { Debug.Assert(edmEnumType != null, "edmEnumType != null"); Debug.Assert(Helper.IsPrimitiveType(edmEnumType.UnderlyingType)); Debug.Assert(Helper.IsSupportedEnumUnderlyingType(edmEnumType.UnderlyingType.PrimitiveTypeKind)); Debug.Assert(objectEnumType != null, "objectEnumType != null"); Debug.Assert(Helper.IsPrimitiveType(objectEnumType.UnderlyingType)); Debug.Assert(Helper.IsSupportedEnumUnderlyingType(objectEnumType.UnderlyingType.PrimitiveTypeKind)); if (edmEnumType.UnderlyingType.PrimitiveTypeKind != objectEnumType.UnderlyingType.PrimitiveTypeKind) { throw new MappingException( System.Data.Entity.Strings.Mapping_Enum_OCMapping_UnderlyingTypesMismatch( edmEnumType.UnderlyingType.Name, edmEnumType.FullName, objectEnumType.UnderlyingType.Name, objectEnumType.FullName)); } // EnumMember.Value is just a number so sorting by value is faster than by the name. // The drawback is that there can be multiple members with the same value. To break // the tie we need to sort by name after sorting by value. var edmEnumTypeMembersSortedEnumerator = edmEnumType.Members.OrderBy(m => Convert.ToInt64(m.Value, CultureInfo.InvariantCulture)).ThenBy(m => m.Name).GetEnumerator(); var objectEnumTypeMembersSortedEnumerator = objectEnumType.Members.OrderBy(m => Convert.ToInt64(m.Value, CultureInfo.InvariantCulture)).ThenBy(m => m.Name).GetEnumerator(); if (edmEnumTypeMembersSortedEnumerator.MoveNext()) { while (objectEnumTypeMembersSortedEnumerator.MoveNext()) { if (edmEnumTypeMembersSortedEnumerator.Current.Name == objectEnumTypeMembersSortedEnumerator.Current.Name && edmEnumTypeMembersSortedEnumerator.Current.Value.Equals(objectEnumTypeMembersSortedEnumerator.Current.Value)) { if (!edmEnumTypeMembersSortedEnumerator.MoveNext()) { return; } } } throw new MappingException( System.Data.Entity.Strings.Mapping_Enum_OCMapping_MemberMismatch( objectEnumType.FullName, edmEnumTypeMembersSortedEnumerator.Current.Name, edmEnumTypeMembersSortedEnumerator.Current.Value, edmEnumType.FullName)); } }
internal Type GetClrType(EnumType enumType) { var objectSpaceType = (EnumType)_context.MetadataWorkspace.GetObjectSpaceType(enumType); return _objectSpaceItems.GetClrType(objectSpaceType); }
public virtual Type GetClrType(EnumType item) { return _objectItemCollection.GetClrType(item); }
/// <summary> /// The method returns the underlying CLR type for the specified OSpace enum type argument. /// If the DataSpace of the parameter is not OSpace, the method returns false and sets /// the out parameter to null. /// </summary> /// <param name="objectSpaceType">The OSpace enum type to look up</param> /// <param name="clrType">The CLR enum type of the OSpace argument</param> /// <returns>true on success, false on failure</returns> public bool TryGetClrType(EnumType objectSpaceType, out Type clrType) { return(ObjectItemCollection.TryGetClrType((EdmType)objectSpaceType, out clrType)); }
/// <summary> /// The method returns the underlying CLR type for the specified OSpace type argument. /// If the DataSpace of the parameter is not OSpace, an ArgumentException is thrown. /// </summary> /// <param name="objectSpaceType">The OSpace type to look up</param> /// <returns>The CLR type of the OSpace argument</returns> public Type GetClrType(EnumType objectSpaceType) { return(ObjectItemCollection.GetClrType((EdmType)objectSpaceType)); }