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>
// 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 (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));
}
}
}
/// <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;
}
