internal static void ValidateFacets( SchemaElement element, SchemaType type, TypeUsageBuilder typeUsageBuilder) { if (type != null) { SchemaEnumType schemaEnumType = type as SchemaEnumType; if (schemaEnumType != null) { typeUsageBuilder.ValidateEnumFacets(schemaEnumType); } else { if (type is ScalarType || !typeUsageBuilder.HasUserDefinedFacets) { return; } element.AddError(ErrorCode.FacetOnNonScalarType, EdmSchemaErrorSeverity.Error, (object)Strings.FacetsOnNonScalarType((object)type.FQName)); } } else { if (!typeUsageBuilder.HasUserDefinedFacets) { return; } element.AddError(ErrorCode.IncorrectlyPlacedFacet, EdmSchemaErrorSeverity.Error, (object)Strings.FacetDeclarationRequiresTypeAttribute); } }
private void HandleEnumTypeElement(XmlReader reader) { SchemaEnumType schemaEnumType = new SchemaEnumType(this); schemaEnumType.Parse(reader); this.TryAddType((SchemaType)schemaEnumType, true); }
// <summary> // Handler for the EnumType element. // </summary> // <param name="reader"> Source xml reader currently positioned on the EnumType element. </param> private void HandleEnumTypeElement(XmlReader reader) { DebugCheck.NotNull(reader); var enumType = new SchemaEnumType(this); enumType.Parse(reader); TryAddType(enumType, doNotAddErrorForEmptyName: true); }
internal void ValidateEnumFacets(SchemaEnumType schemaEnumType) { foreach (KeyValuePair <string, object> facetValue in this._facetValues) { if (facetValue.Key != "Nullable" && facetValue.Key != "StoreGeneratedPattern" && facetValue.Key != "ConcurrencyMode") { this._element.AddError(ErrorCode.FacetNotAllowedByType, EdmSchemaErrorSeverity.Error, (object)Strings.FacetNotAllowed((object)facetValue.Key, (object)schemaEnumType.FQName)); } } }
internal void ValidateEnumFacets(SchemaEnumType schemaEnumType) { foreach (var value in _facetValues) { if (value.Key != DbProviderManifest.NullableFacetName && value.Key != EdmProviderManifest.StoreGeneratedPatternFacetName && value.Key != EdmProviderManifest.ConcurrencyModeFacetName) { _element.AddError( ErrorCode.FacetNotAllowedByType, EdmSchemaErrorSeverity.Error, Strings.FacetNotAllowed(value.Key, schemaEnumType.FQName)); } } }
internal override void Validate() { base.Validate(); if (this._collectionKind != CollectionKind.Bag) { int collectionKind = (int)this._collectionKind; } SchemaEnumType type = this._type as SchemaEnumType; if (type != null) { this._typeUsageBuilder.ValidateEnumFacets(type); } else { if (!this.Nullable || this.Schema.SchemaVersion == 1.1 || !(this._type is SchemaComplexType)) { return; } this.AddError(ErrorCode.NullableComplexType, EdmSchemaErrorSeverity.Error, (object)Strings.ComplexObject_NullableComplexTypesNotSupported((object)this.FQName)); } }
/// <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(SchemaEnumType somEnumType, Dictionary<SchemaElement, GlobalItem> newGlobalItems) { DebugCheck.NotNull(somEnumType); DebugCheck.NotNull(newGlobalItems); Debug.Assert( somEnumType.UnderlyingType is ScalarType, "At this point the underlying type should have already been validated and should be ScalarType"); var enumUnderlyingType = (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; }