/// <summary> /// Computes values for enum members in the model with unspecified values. /// </summary> /// <param name="enumType">An enum type.</param> /// <returns>List of enum members with all values resolved.</returns> public IEnumerable<EnumMember> CalculateEnumMemberValues(EnumType enumType) { var enumMembers = new List<EnumMember>(); long nextValue = 0; // Unspecified values are calculated based on the last specified value. foreach (var enumMember in enumType.Members) { object value = null; if (enumMember.Value != null) { value = enumMember.Value; nextValue = Convert.ToInt64(enumMember.Value, CultureInfo.InvariantCulture) + 1; } else { value = nextValue; nextValue++; } var resolvedEnumMember = this.CalculateValue(enumType, enumMember.Name, value); enumMembers.Add(resolvedEnumMember); } return enumMembers; }
private EnumMember CalculateValue(EnumType enumType, string name, object value) { EnumMember enumMember; if (enumType.UnderlyingType == null) { enumMember = new EnumMember(name, Convert.ChangeType(value, typeof(int), CultureInfo.InvariantCulture)); } else { enumMember = new EnumMember(name, Convert.ChangeType(value, enumType.UnderlyingType, CultureInfo.InvariantCulture)); } return enumMember; }
private XElement GenerateEnumType(EnumType enumType, XNamespace xmlNamespace) { return new XElement( xmlNamespace + "EnumType", new XAttribute("Name", enumType.Name), enumType.IsFlags == null ? null : new XAttribute("IsFlags", enumType.IsFlags), enumType.UnderlyingType == null ? null : new XAttribute("UnderlyingType", this.GetEdmNameForUnderlyingType(enumType.UnderlyingType)), this.GenerateDocumentation(xmlNamespace, enumType), this.GenerateEnumMembers(enumType.Members, xmlNamespace), this.GenerateAnnotations(xmlNamespace, enumType)); }
/// <summary> /// Removes an <see cref="EnumType"/> from the model /// </summary> /// <param name="enumType">Enum type to be removed</param> public void Remove(EnumType enumType) { ExceptionUtilities.CheckArgumentNotNull(enumType, "enumType"); ExceptionUtilities.Assert(enumType.Model == this, "Enum type was not added to this model"); ExceptionUtilities.Assert(this.enumTypesList.Remove(enumType), "Enum type was not added to this model"); enumType.Model = null; }
/// <summary> /// Adds new <see cref="EnumType"/> to the model /// </summary> /// <param name="enumType">Enum type to be added</param> public void Add(EnumType enumType) { ExceptionUtilities.CheckArgumentNotNull(enumType, "enumType"); ExceptionUtilities.Assert(enumType.Model == null, "Enum type was already added to another model"); enumType.Model = this; this.enumTypesList.Add(enumType); }
private EnumType ConvertToTaupoEnumType(IEdmEnumType edmEnum) { var taupoEnumType = new EnumType(edmEnum.Namespace, edmEnum.Name); if (edmEnum.IsFlags) { taupoEnumType.IsFlags = true; } if (edmEnum.UnderlyingType != null) { taupoEnumType.UnderlyingType = this.ConvertToClrType(edmEnum.UnderlyingType); } foreach (var edmEnumMember in edmEnum.Members) { var taupoEnumMember = new EnumMember(edmEnumMember.Name); if (edmEnumMember.Value != null) { taupoEnumMember.Value = this.ConvertToClrObject(edmEnumMember.Value); } taupoEnumType.Add(taupoEnumMember); } return taupoEnumType; }
private void CompareEnumMember(EnumType expectedEnumType, EnumMember expectedMemeber, EnumType actualEnumType, EnumMember actualMember) { this.SatisfiesEquals(expectedMemeber.Name, actualMember.Name, "Enum member name not match."); this.SatisfiesEquals(this.GetIntegralEnumMemberValue(expectedEnumType, expectedMemeber), this.GetIntegralEnumMemberValue(actualEnumType, actualMember), "Enum member value does not match."); this.CompareAnnotations(expectedMemeber.Annotations, actualMember.Annotations); }
private void CompareEnumMembers(EnumType expectedEnumType, EnumType actualEnumType) { this.SatisfiesEquals(expectedEnumType.Members.Count, actualEnumType.Members.Count, "Count of Members of '{0}' does not match.", expectedEnumType.FullName); foreach (var expectedMemeber in expectedEnumType.Members) { var actualMembers = actualEnumType.Members.Where(m => m.Name == expectedMemeber.Name); if (this.SatisfiesEquals(1, actualMembers.Count(), "Should find exactly one member '{0}'.", expectedMemeber.Name)) { var actualMember = actualMembers.Single(); this.CompareEnumMember(expectedEnumType, expectedMemeber, actualEnumType, actualMember); } } }
private object GetIntegralEnumMemberValue(EnumType enumType, EnumMember enumMember) { var targetEnumMember = enumType.Members.Single(n => n == enumMember); if (targetEnumMember.Value != null) { long integralValue = 0; if (long.TryParse(targetEnumMember.Value.ToString(), out integralValue)) { return integralValue; } return targetEnumMember.Value; } if (enumType.Members.ElementAt(0) == targetEnumMember) { return 0L; } int memberIndex = 0; for (int i = 1; i < enumType.Members.Count; ++i) { if (enumType.Members.ElementAt(i) == targetEnumMember) { memberIndex = i; break; } } var previousMember = enumType.Members.ElementAt(memberIndex - 1); var previousValue = previousMember.Value; if (previousValue == null) { previousValue = this.GetIntegralEnumMemberValue(enumType, previousMember); } long previousIntegralValue = 0; if (long.TryParse(previousValue.ToString(), out previousIntegralValue)) { return previousIntegralValue + 1; } else { return targetEnumMember.Value; } }
private void CompareEnumType(EnumType expectedEnumType, EnumType actualEnumType) { this.SatisfiesEquals(expectedEnumType.FullName, actualEnumType.FullName, "Enum type name does not match."); if (expectedEnumType.IsFlags == null) { this.SatisfiesCondition(actualEnumType.IsFlags == null, "IsFlags should be null."); } else { this.SatisfiesEquals(expectedEnumType.IsFlags, actualEnumType.IsFlags, "IsFlags does not match."); } if (expectedEnumType.UnderlyingType == null) { this.SatisfiesCondition(actualEnumType.UnderlyingType == null, "Underlying type should be null."); } else { this.SatisfiesEquals(expectedEnumType.UnderlyingType, actualEnumType.UnderlyingType, "Underlying type does not match."); } this.CompareEnumMembers(expectedEnumType, actualEnumType); }
private EnumType ParseEnumType(XElement enumTypeElement) { string name = enumTypeElement.GetRequiredAttributeValue("Name"); string underlyingTypeString = enumTypeElement.GetOptionalAttributeValue("UnderlyingType", null); Type underlyingType = null; if (underlyingTypeString != null) { string underlyingTypeName = this.ParseEdmTypeName(underlyingTypeString)[1]; underlyingType = Type.GetType("System." + underlyingTypeName); } var isFlagsString = enumTypeElement.Attribute("IsFlags"); var enumType = new EnumType(this.CurrentNamespace, name) { IsFlags = isFlagsString == null ? (bool?)null : bool.Parse(isFlagsString.Value), UnderlyingType = underlyingType }; foreach (var memberElement in enumTypeElement.Elements().Where(el => this.IsXsdlElement(el, "Member"))) { enumType.Members.Add(this.ParseEnumMember(memberElement)); } this.ParseAnnotations(enumType, enumTypeElement); return enumType; }
/// <summary> /// Builds a code representation of an <see cref="EnumType"/>. /// </summary> /// <param name="type">The <see cref="EnumType"/> from which to generate code.</param> /// <returns>A <see cref="CodeTypeDeclaration"/> which represents the <see cref="EnumType"/>.</returns> protected virtual CodeTypeDeclaration BuildType(EnumType type) { var codeEnum = new CodeTypeDeclaration(type.Name); codeEnum.IsEnum = true; if (type.UnderlyingType != null) { codeEnum.BaseTypes.Add(type.UnderlyingType); } if (type.IsFlags == true) { codeEnum.AddCustomAttribute(typeof(FlagsAttribute)); } ApplyTypeAccessModifier(codeEnum, type.Annotations.OfType<TypeAccessModifierAnnotation>().SingleOrDefault()); if (type.Annotations.Any(a => a is SerializableAnnotation)) { codeEnum.AddCustomAttribute(typeof(SerializableAttribute)); } this.AddEnumMembers(codeEnum, type); return codeEnum; }
/// <summary> /// Adds enum members to the generated type class. /// </summary> /// <param name="codeEnum">The <see cref="CodeTypeDeclaration"/> to which to add the enum members.</param> /// <param name="type">The definition of the enum type.</param> protected virtual void AddEnumMembers(CodeTypeDeclaration codeEnum, EnumType type) { foreach (var member in type.Members) { var codeMember = new CodeMemberField(codeEnum.Name, member.Name); if (member.Value != null) { codeMember.InitExpression = new CodeSnippetExpression(member.Value.ToString()); } codeEnum.Members.Add(codeMember); } }
/// <summary> /// Visit Enum type /// </summary> /// <param name="enumType">enum type to visit</param> protected virtual void VisitEnumType(EnumType enumType) { this.VisitAnnotatedItem(enumType); foreach (var enumMember in enumType.Members) { this.VisitEnumMember(enumMember); } }
private QueryScalarType CreateStubEnumType(EnumType enumType) { return new QueryClrEnumType(this.EvaluationStrategy, enumType, null); }