public static EdmProperty Enum(string name, EnumType enumType) { Check.NotEmpty(name, "name"); Check.NotNull(enumType, "enumType"); return CreateProperty(name, enumType); }
internal virtual bool TryGetEnumMember(EnumType type, String memberName, bool ignoreCase, out EnumMember outMember) { DebugCheck.NotNull(type); Check.NotEmpty(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); }
public void IsEnumType_returns_true_when_enum_property() { var enumType = new EnumType(); var property = EdmProperty.Enum("P", enumType); Assert.False(property.IsComplexType); Assert.False(property.IsPrimitiveType); Assert.True(property.IsEnumType); }
public void Enum_should_create_enum_property() { var enumType = new EnumType(); var property = EdmProperty.CreateEnum("P", enumType); Assert.NotNull(property); Assert.NotNull(property.TypeUsage); Assert.Same(enumType, property.TypeUsage.EdmType); }
public void Should_be_able_to_get_and_set_clr_type() { var enumType = new EnumType(); Assert.Null(enumType.GetClrType()); enumType.SetClrType(typeof(object)); Assert.Equal(typeof(object), enumType.GetClrType()); }
public void GetClrType_returns_CLR_type_annotation_for_EnumType() { var enumType = new EnumType(); Assert.Null(((EdmType)enumType).GetClrType()); enumType.Annotations.SetClrType(typeof(Random)); Assert.Same(typeof(Random), ((EdmType)enumType).GetClrType()); }
public void Can_set_and_get_underlying_type() { var enumType = new EnumType(); var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int64); enumType.UnderlyingType = primitiveType; Assert.Same(primitiveType, enumType.UnderlyingType); }
private bool TryCreateEnumType(Type enumType, EnumType cspaceEnumType, out EdmType newOSpaceType) { DebugCheck.NotNull(enumType); Debug.Assert(enumType.IsEnum(), "enum type expected"); DebugCheck.NotNull(cspaceEnumType); Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected"); 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); LoadedTypes.Add(enumType.FullName, newOSpaceType); return true; }
protected override void VisitEdmEnumType(EnumType item) { _schemaWriter.WriteEnumTypeElementHeader(item); base.VisitEdmEnumType(item); _schemaWriter.WriteEndElement(); }
/// <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"); var enumUnderlyingType = (Som.ScalarType)somEnumType.UnderlyingType; // note that enums don't live in SSpace so there is no need to GetDataSpace() for it. var enumType = new EnumType( somEnumType.Name, somEnumType.Namespace, enumUnderlyingType.Type, somEnumType.IsFlags, DataSpace.CSpace); var 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; }
public bool TryGetClrType(EnumType objectSpaceType, out Type clrType) { return(TryGetClrType((EdmType)objectSpaceType, out clrType)); }
public static EnumType Create( string name, string namespaceName, PrimitiveType underlyingType, bool isFlags, IEnumerable<EnumMember> members, IEnumerable<MetadataProperty> metadataProperties) { Check.NotEmpty(name, "name"); Check.NotEmpty(namespaceName, "namespaceName"); Check.NotNull(underlyingType, "underlyingType"); if (!Helper.IsSupportedEnumUnderlyingType(underlyingType.PrimitiveTypeKind)) { throw new ArgumentException(Strings.InvalidEnumUnderlyingType, "underlyingType"); } var instance = new EnumType(name, namespaceName, underlyingType, isFlags, DataSpace.CSpace); if (members != null) { foreach (var member in members) { if (!Helper.IsEnumMemberValueInRange( underlyingType.PrimitiveTypeKind, Convert.ToInt64(member.Value, CultureInfo.InvariantCulture))) { throw new ArgumentException( Strings.EnumMemberValueOutOfItsUnderylingTypeRange( member.Value, member.Name, underlyingType.Name), "members"); } instance.AddMember(member); } } if (metadataProperties != null) { instance.AddMetadataProperties(metadataProperties.ToList()); } instance.SetReadOnly(); return instance; }
public virtual Type GetClrType(EnumType item) { return _objectItemCollection.GetClrType(item); }
public void IsUnderlyingPrimitiveType_returns_true_when_underlying_primitive_property() { var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32); var property = EdmProperty.CreatePrimitive("P", primitiveType); Assert.True(property.IsUnderlyingPrimitiveType); var enumType = new EnumType(); property = EdmProperty.CreateEnum("P", enumType); Assert.True(property.IsUnderlyingPrimitiveType); }
public void UnderlyingPrimitiveType_returns_type_when_underlying_primitive_property() { var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32); var property = EdmProperty.CreatePrimitive("P", primitiveType); Assert.Same(primitiveType, property.UnderlyingPrimitiveType); var enumType = new EnumType(); property = EdmProperty.CreateEnum("P", enumType); Assert.Same(primitiveType, property.UnderlyingPrimitiveType); var complexType = new ComplexType(); property = EdmProperty.CreateComplex("P", complexType); Assert.Null(property.UnderlyingPrimitiveType); }
/// <summary> /// Removes an enumeration type from the model. /// </summary> /// <param name="item">The EnumType instance to be removed.</param> public void RemoveItem(EnumType item) { Check.NotNull(item, "item"); _enumTypes.Remove(item); }
/// <summary> /// Adds an enumeration type to the model. /// </summary> /// <param name="item">The EnumType instance to be added.</param> public void AddItem(EnumType item) { Check.NotNull(item, "item"); ValidateSpace(item); _enumTypes.Add(item); }
protected override void Visit(EnumType enumType) { int index; if (!AddObjectToSeenListAndHashBuilder(enumType, out index)) { return; } AddObjectStartDumpToHashBuilder(enumType, index); AddObjectContentToHashBuilder(enumType.Identity); Visit(enumType.UnderlyingType); base.Visit(enumType); AddObjectEndDumpToHashBuilder(); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_entity_types() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var cSpaceEntityType = new EntityType(typeof(ManyTypesEntity).Name, "N", DataSpace.CSpace); cSpaceEntityType.AddMember( new EdmProperty("P1Bool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P2NullableBool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = true }))); cSpaceEntityType.AddMember( new EdmProperty("P3ByteArray", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary)))); cSpaceEntityType.AddMember( new EdmProperty("P4Timespan", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P5NullableTimespan", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = true }))); var enumType = new EnumType( "DayOfWeek", "N", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace); cSpaceEntityType.AddMember( new EdmProperty("P6Enum", TypeUsage.Create(enumType, new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P7NullableEnum", TypeUsage.Create(enumType, new FacetValues { Nullable = true }))); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); cSpaceEntityType.AddMember( new EdmProperty("P8Geography", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geography)))); var oSpaceTypeFactory = new CodeFirstOSpaceTypeFactory(); var oSpaceEntityType = oSpaceTypeFactory.TryCreateType(typeof(ManyTypesEntity), cSpaceEntityType); oSpaceTypeFactory.CspaceToOspace.Add(enumType, oSpaceTypeFactory.TryCreateType(typeof(DayOfWeek), enumType)); foreach (var resolve in oSpaceTypeFactory.ReferenceResolutions) { resolve(); } var scalarMaps = new List<ScalarColumnMap>(); foreach (var edmProperty in cSpaceEntityType.Properties) { scalarMaps.Add(new ScalarColumnMap(edmProperty.TypeUsage, edmProperty.Name, 0, scalarMaps.Count)); } var entityMap = new EntityColumnMap( entityTypeUsage, "E", scalarMaps.ToArray(), new SimpleEntityIdentity(null, new SimpleColumnMap[] { scalarMaps[0] })); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", entityMap, null, null); metadataWorkspaceMock.Setup(m => m.GetItem<EdmType>(It.IsAny<string>(), DataSpace.OSpace)) .Returns(oSpaceEntityType); var factory = new Translator().TranslateColumnMap<object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal( new[] { typeof(bool), typeof(bool), typeof(byte[]), typeof(TimeSpan), typeof(TimeSpan), typeof(int), typeof(int), typeof(DbGeography) }, factory.ColumnTypes); // The first column is nullable as it's part of the key Assert.Equal(new[] { true, true, true, false, true, false, true, true }, factory.NullableColumns); }
private bool UnderlyingEnumTypesMatch(Type enumType, EnumType cspaceEnumType) { DebugCheck.NotNull(enumType); Debug.Assert(enumType.IsEnum(), "expected enum OSpace type"); DebugCheck.NotNull(cspaceEnumType); 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)) { LogLoadMessage( Strings.Validator_UnsupportedEnumUnderlyingType(enumType.GetEnumUnderlyingType().FullName), cspaceEnumType); return false; } else if (underlyingEnumType.PrimitiveTypeKind != cspaceEnumType.UnderlyingType.PrimitiveTypeKind) { LogLoadMessage( Strings.Validator_OSpace_Convention_NonMatchingUnderlyingTypes, cspaceEnumType); return false; } return true; }
public void EnumType_returns_type_when_enum_property() { var enumType = new EnumType(); var property = EdmProperty.CreateEnum("P", enumType); Assert.Same(enumType, property.EnumType); }
public static EnumType AddEnumType(this EdmModel model, string name, string modelNamespace = null) { DebugCheck.NotNull(model); DebugCheck.NotEmpty(name); var enumType = new EnumType( name, modelNamespace ?? DefaultModelNamespace, PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace); model.AddItem(enumType); return enumType; }
internal void WriteEnumTypeElementHeader(EnumType enumType) { DebugCheck.NotNull(enumType); _xmlWriter.WriteStartElement(XmlConstants.EnumType); _xmlWriter.WriteAttributeString(XmlConstants.Name, enumType.Name); _xmlWriter.WriteAttributeString( XmlConstants.IsFlags, GetLowerCaseStringFromBoolValue(enumType.IsFlags)); if (enumType.UnderlyingType != null) { _xmlWriter.WriteAttributeString( XmlConstants.UnderlyingType, enumType.UnderlyingType.PrimitiveTypeKind.ToString()); } }
private bool EnumMembersMatch(Type enumType, EnumType cspaceEnumType) { DebugCheck.NotNull(enumType); Debug.Assert(enumType.IsEnum(), "expected enum OSpace type"); DebugCheck.NotNull(cspaceEnumType); 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; } } } LogLoadMessage( Strings.Mapping_Enum_OCMapping_MemberMismatch( enumType.FullName, cspaceSortedEnumMemberEnumerator.Current.Name, cspaceSortedEnumMemberEnumerator.Current.Value, cspaceEnumType.FullName), cspaceEnumType); return false; }
private void AddReference(Dictionary<string, EnumLookupTable> enumSet, EnumType enumType, TableReference reference) { EnumLookupTable entry; if (enumSet.TryGetValue(enumType.FullName, out entry)) { entry.References.Add(reference); } else { var enumInfo = new EnumLookupTable(enumType, reference); enumSet.Add(enumType.FullName, enumInfo); } }
protected virtual void Visit(EnumType enumType) { foreach (var member in enumType.Members) { Visit(member); } }
public EnumLookupTable(EnumType enumType, TableReference reference) { EnumType = enumType; Rows = new List<EnumLookupTableRow>(); if (enumType.IsFlags) { foreach (var enumField in enumType.Members) { var enumValue = enumField.Value; switch (enumType.UnderlyingType.PrimitiveTypeKind) { case PrimitiveTypeKind.Byte: case PrimitiveTypeKind.SByte: if (((byte)enumValue & ((byte)enumValue - 1)) != 0) { // composed enum value continue; } break; case PrimitiveTypeKind.Int16: if (((short)enumValue & ((short)enumValue - 1)) != 0) { // composed enum value continue; } break; case PrimitiveTypeKind.Int32: if (((int)enumValue & ((int)enumValue - 1)) != 0) { // composed enum value continue; } break; case PrimitiveTypeKind.Int64: if (((long)enumValue & ((long)enumValue - 1)) != 0) { // composed enum value continue; } break; default: throw new ArgumentOutOfRangeException(); } var name = enumField.Name.SeparateWords(); Rows.Add(new EnumLookupTableRow { Id = enumValue.ToString(), Name = name }); } } else { foreach (var enumField in enumType.Members) { var enumValue = enumField.Value.ToString(); var name = enumField.Name.SeparateWords(); Rows.Add(new EnumLookupTableRow { Id = enumValue, Name = name }); } } References = new List<TableReference> { reference }; }
public void Can_add_remove_enum_type() { var model = new EdmModel(DataSpace.SSpace); var enumType = new EnumType { DataSpace = DataSpace.SSpace }; model.AddItem(enumType); Assert.True(model.EnumTypes.Contains(enumType)); Assert.True(model.NamespaceItems.Contains(enumType)); model.RemoveItem(enumType); Assert.False(model.EnumTypes.Contains(enumType)); Assert.False(model.NamespaceItems.Contains(enumType)); }
/// <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; }
/// <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( 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( Strings.Mapping_Enum_OCMapping_MemberMismatch( objectEnumType.FullName, edmEnumTypeMembersSortedEnumerator.Current.Name, edmEnumTypeMembersSortedEnumerator.Current.Value, edmEnumType.FullName)); } }
public Type GetClrType(EnumType objectSpaceType) { return(GetClrType((EdmType)objectSpaceType)); }