private static EnumType ConvertToEnumType(
SchemaEnumType somEnumType,
Dictionary <SchemaElement, GlobalItem> newGlobalItems)
{
ScalarType underlyingType = (ScalarType)somEnumType.UnderlyingType;
EnumType enumType = new EnumType(somEnumType.Name, somEnumType.Namespace, underlyingType.Type, somEnumType.IsFlags, DataSpace.CSpace);
Type clrEquivalentType = underlyingType.Type.ClrEquivalentType;
foreach (SchemaEnumMember enumMember1 in somEnumType.EnumMembers)
{
EnumMember enumMember2 = new EnumMember(enumMember1.Name, Convert.ChangeType((object)enumMember1.Value, clrEquivalentType, (IFormatProvider)CultureInfo.InvariantCulture));
if (enumMember1.Documentation != null)
{
enumMember2.Documentation = Converter.ConvertToDocumentation(enumMember1.Documentation);
}
Converter.AddOtherContent((SchemaElement)enumMember1, (MetadataItem)enumMember2);
enumType.AddMember(enumMember2);
}
if (somEnumType.Documentation != null)
{
enumType.Documentation = Converter.ConvertToDocumentation(somEnumType.Documentation);
}
Converter.AddOtherContent((SchemaElement)somEnumType, (MetadataItem)enumType);
newGlobalItems.Add((SchemaElement)somEnumType, (GlobalItem)enumType);
return(enumType);
}
public static EnumType Create(
string name,
string namespaceName,
PrimitiveType underlyingType,
bool isFlags,
IEnumerable <EnumMember> members,
IEnumerable <MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, nameof(name));
Check.NotEmpty(namespaceName, nameof(namespaceName));
Check.NotNull <PrimitiveType>(underlyingType, nameof(underlyingType));
if (!Helper.IsSupportedEnumUnderlyingType(underlyingType.PrimitiveTypeKind))
{
throw new ArgumentException(Strings.InvalidEnumUnderlyingType, nameof(underlyingType));
}
EnumType enumType = new EnumType(name, namespaceName, underlyingType, isFlags, DataSpace.CSpace);
if (members != null)
{
foreach (EnumMember member in members)
{
if (!Helper.IsEnumMemberValueInRange(underlyingType.PrimitiveTypeKind, Convert.ToInt64(member.Value, (IFormatProvider)CultureInfo.InvariantCulture)))
{
throw new ArgumentException(Strings.EnumMemberValueOutOfItsUnderylingTypeRange(member.Value, (object)member.Name, (object)underlyingType.Name), nameof(members));
}
enumType.AddMember(member);
}
}
if (metadataProperties != null)
{
enumType.AddMetadataProperties(metadataProperties.ToList <MetadataProperty>());
}
enumType.SetReadOnly();
return(enumType);
}
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);
}
private static void InitializeEnumType(
BuiltInTypeKind builtInTypeKind,
string name,
string[] enumMemberNames)
{
EnumType builtInType = (EnumType)MetadataItem.GetBuiltInType(builtInTypeKind);
EdmType.Initialize((EdmType)builtInType, name, "Edm", DataSpace.CSpace, false, (EdmType)null);
for (int index = 0; index < enumMemberNames.Length; ++index)
{
builtInType.AddMember(new EnumMember(enumMemberNames[index], (object)index));
}
}
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);
}
instance.SetReadOnly();
return(instance);
}
static Converter()
{
EnumType enumType1 = new EnumType("ConcurrencyMode", "Edm", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace);
foreach (string name in Enum.GetNames(typeof(ConcurrencyMode)))
{
enumType1.AddMember(new EnumMember(name, (object)(int)Enum.Parse(typeof(ConcurrencyMode), name, false)));
}
EnumType enumType2 = new EnumType("StoreGeneratedPattern", "Edm", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace);
foreach (string name in Enum.GetNames(typeof(StoreGeneratedPattern)))
{
enumType2.AddMember(new EnumMember(name, (object)(int)Enum.Parse(typeof(StoreGeneratedPattern), name, false)));
}
Converter.ConcurrencyModeFacet = new FacetDescription("ConcurrencyMode", (EdmType)enumType1, new int?(), new int?(), (object)ConcurrencyMode.None);
Converter.StoreGeneratedPatternFacet = new FacetDescription("StoreGeneratedPattern", (EdmType)enumType2, new int?(), new int?(), (object)StoreGeneratedPattern.None);
Converter.CollationFacet = new FacetDescription("Collation", (EdmType)MetadataItem.EdmProviderManifest.GetPrimitiveType(PrimitiveTypeKind.String), new int?(), new int?(), (object)string.Empty);
}
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;
}
/// <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;
}
